Changeset cac8a6e


Ignore:
Timestamp:
May 22, 2018, 11:08:22 AM (3 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, with_gc
Children:
639991a
Parents:
4a333d35 (diff), 2f0a0678 (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

Location:
src
Files:
40 edited

Legend:

Unmodified
Added
Removed
  • src/Common/ScopedMap.h

    r4a333d35 rcac8a6e  
    1010// Created On       : Wed Dec 2 11:37:00 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 21 22:18:24 2017
    13 // Update Count     : 2
     12// Last Modified On : Mon May 21 15:22:40 2018
     13// Update Count     : 3
    1414//
    1515
     
    276276        }
    277277
     278        template< typename value_t >
     279        std::pair< iterator, bool > insertAt( size_type scope, const Key& key, value_t&& value ) {
     280                return insertAt( scope, std::make_pair( key, std::forward<value_t>( value ) ) );
     281        }
     282
    278283        Value& operator[] ( const Key &key ) {
    279284                iterator slot = find( key );
  • src/GenPoly/GenPoly.cc

    r4a333d35 rcac8a6e  
    371371                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
    372372                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
     373                } else if ( aid == type_index{typeid(ReferenceType)} ) {
     374                        ReferenceType *ap = as<ReferenceType>(a), *bp = as<ReferenceType>(b);
     375                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
     376                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
    373377                } else if ( aid == type_index{typeid(ArrayType)} ) {
    374378                        ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
  • src/GenPoly/Lvalue.cc

    r4a333d35 rcac8a6e  
    166166                        if ( isIntrinsicReference( appExpr ) ) {
    167167                                // eliminate reference types from intrinsic applications - now they return lvalues
    168                                 Type * result = appExpr->result;
    169                                 appExpr->result = result->stripReferences()->clone();
     168                                ReferenceType * result = strict_dynamic_cast< ReferenceType * >( appExpr->result );
     169                                appExpr->result = result->base->clone();
    170170                                appExpr->result->set_lvalue( true );
    171171                                if ( ! inIntrinsic ) {
     
    183183                void FixIntrinsicResult::premutate( FunctionDecl * funcDecl ) {
    184184                        GuardValue( inIntrinsic );
    185                         inIntrinsic =  funcDecl->linkage == LinkageSpec::Intrinsic;
     185                        inIntrinsic = funcDecl->linkage == LinkageSpec::Intrinsic;
    186186                }
    187187
     
    403403                                        ret = new AddressExpr( ret );
    404404                                }
    405                                 if ( srcType->get_lvalue() && srcType->get_qualifiers() != strict_dynamic_cast<ReferenceType *>( destType )->base->get_qualifiers() ) {
     405                                if ( srcType->get_lvalue() && ! ResolvExpr::typesCompatible( srcType, strict_dynamic_cast<ReferenceType *>( destType )->base, SymTab::Indexer() ) ) {
    406406                                        // must keep cast if cast-to type is different from the actual type
    407407                                        castExpr->arg = ret;
  • src/Parser/DeclarationNode.cc

    r4a333d35 rcac8a6e  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed May 16 09:37:17 2018
    13 // Update Count     : 1070
     12// Last Modified On : Tue May 22 08:39:29 2018
     13// Update Count     : 1074
    1414//
    1515
     
    3232#include "SynTree/Type.h"          // for Type, Type::StorageClasses, Type::...
    3333#include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
    34 #include "TypedefTable.h"          // for TypedefTable, TypedefTable::kind_t...
     34#include "TypedefTable.h"          // for TypedefTable
    3535
    3636class Initializer;
     
    5454
    5555DeclarationNode::DeclarationNode() :
     56                builtin( NoBuiltinType ),
    5657                type( nullptr ),
    5758                bitfieldWidth( nullptr ),
     
    101102        newnode->name = name ? new string( *name ) : nullptr;
    102103
     104        newnode->builtin = NoBuiltinType;
    103105        newnode->type = maybeClone( type );
    104106        newnode->storageClasses = storageClasses;
     
    179181        newnode->type->function.body = body;
    180182
    181         // ignore unnamed routine declarations: void p( int (*)(int) );
    182         if ( newnode->name ) {
    183                 typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
    184         } // if
    185 
    186183        if ( ret ) {
    187184                newnode->type->base = ret->type;
     
    285282        newnode->name = name;
    286283        newnode->enumeratorValue.reset( constant );
    287         typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
    288284        return newnode;
    289285} // DeclarationNode::newEnumConstant
     
    551547                                        type->aggregate.params = q->type->forall; // make polymorphic type
    552548                                        // change implicit typedef from TYPEDEFname to TYPEGENname
    553                                         typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
     549                                        typedefTable.changeKind( *type->aggregate.name, TYPEGENname );
    554550                                } // if
    555551                        } else {                                                                        // not polymorphic
  • src/Parser/TypedefTable.cc

    r4a333d35 rcac8a6e  
    77// TypedefTable.cc --
    88//
    9 // Author           : Rodolfo G. Esteves
     9// Author           : Peter A. Buhr
    1010// Created On       : Sat May 16 15:20:13 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Aug 15 18:24:42 2016
    13 // Update Count     : 25
     12// Last Modified On : Tue May 22 08:40:01 2018
     13// Update Count     : 121
    1414//
    1515
    16 #include <ext/alloc_traits.h>    // for __alloc_traits<>::value_type
    17 #include <cassert>               // for assert
    18 #include <list>                  // for list, _List_iterator, list<>::iterator
    19 #include <map>                   // for _Rb_tree_iterator, _Rb_tree_const_it...
    20 #include <memory>                // for allocator_traits<>::value_type
    21 #include <utility>               // for pair
    2216
    23 #include "Parser/ParserTypes.h"  // for typedefTable
    24 #include "Parser/parser.hh"      // for IDENTIFIER
    2517#include "TypedefTable.h"
    26 
    27 using namespace std;
     18#include <cassert>                                                                              // for assert
    2819
    2920#if 0
    3021#include <iostream>
    31 
    3222#define debugPrint( x ) cerr << x
    3323#else
     
    3525#endif
    3626
    37 TypedefTable::TypedefTable() : currentScope( 0 ) {}
     27using namespace std;                                                                    // string, iostream
    3828
    39 bool TypedefTable::exists( const string &identifier ) {
    40         return table.count( identifier ) > 0;
    41 }
     29TypedefTable::~TypedefTable() {
     30        if ( ! SemanticErrorThrow && kindTable.currentScope() != 0 ) {
     31                // std::cerr << "scope failure " << kindTable.currentScope() << endl;
     32        } // if
     33} // TypedefTable::~TypedefTable
    4234
    43 int TypedefTable::isKind( const string &identifier ) const {
    44         tableType::const_iterator id_pos = table.find( identifier );
     35bool TypedefTable::exists( const string & identifier ) {
     36        return kindTable.find( identifier ) != kindTable.end();
     37} // TypedefTable::exists
     38
     39int TypedefTable::isKind( const string & identifier ) const {
     40        KindTable::const_iterator posn = kindTable.find( identifier );
    4541        // Name lookup defaults to identifier, and then the identifier's kind is set by the parser.
    46         if ( id_pos == table.end() ) return IDENTIFIER;
    47         return id_pos->second.begin()->kind;
    48 }
     42        if ( posn == kindTable.end() ) return IDENTIFIER;
     43        return posn->second;
     44} // TypedefTable::isKind
    4945
    50 void TypedefTable::changeKind( const string &identifier, kind_t kind ) {
    51         tableType::iterator id_pos = table.find( identifier );
    52         if ( id_pos == table.end() ) return;
    53         id_pos->second.begin()->kind = kind;
    54 }
     46void TypedefTable::changeKind( const string & identifier, int kind ) {
     47        KindTable::iterator posn = kindTable.find( identifier );
     48        if ( posn != kindTable.end() ) posn->second = kind;     // exists => update
     49} // TypedefTable::changeKind
    5550
    5651// SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by
    57 // "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed
    58 // if the name is explicitly used.
    59 void TypedefTable::makeTypedef( const string &name ) {
     52// "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if the
     53// name is explicitly used.
     54void TypedefTable::makeTypedef( const string & name ) {
    6055        if ( ! typedefTable.exists( name ) ) {
    61                 typedefTable.addToEnclosingScope( name, TypedefTable::TD );
     56                typedefTable.addToEnclosingScope( name, TYPEDEFname );
    6257        } // if
    63 }
     58} // TypedefTable::makeTypedef
    6459
    65 void TypedefTable::addToScope( const std::string &identifier, kind_t kind, int scope ) {
    66         if ( currentTrait != "" && scope == contextScope ) {
    67                 DeferredEntry entry = { identifier, kind };
    68                 contexts[currentTrait].push_back( entry );
    69         } else {
    70                 debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << " from scope " << currentScope << endl );
    71                 Entry newEntry = { scope, kind };
    72                 tableType::iterator curPos = table.find( identifier );
    73                 if ( curPos == table.end()) {
    74                         list< Entry > newList;
    75                         newList.push_front( newEntry );
    76                         table[identifier] = newList;
    77                 } else {
    78                         list< Entry >::iterator listPos = (*curPos ).second.begin();
    79                         while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
    80                                 listPos++;
    81                         } // while
    82                         (*curPos ).second.insert( listPos, newEntry );
    83                 } // if
    84         } // if
    85 }
    86 
    87 void TypedefTable::addToCurrentScope( const std::string &identifier, kind_t kind ) {
    88         addToScope( identifier, kind, currentScope );
    89 }
    90 
    91 void TypedefTable::addToCurrentScope( kind_t kind ) {
    92         addToCurrentScope( nextIdentifiers.top(), kind );
    93 }
    94 
    95 void TypedefTable::addToEnclosingScope( const std::string &identifier, kind_t kind ) {
    96         assert( currentScope >= 1 );
    97         addToScope( identifier, kind, currentScope - 1 );
    98 }
    99 
    100 void TypedefTable::addToEnclosingScope( kind_t kind ) {
    101         addToEnclosingScope( nextIdentifiers.top(), kind );
    102 }
    103 
    104 void TypedefTable::addToEnclosingScope2( const std::string &identifier, kind_t kind ) {
    105         assert( currentScope >= 2 );
    106         addToScope( identifier, kind, currentScope - 2 );
    107 }
    108 
    109 void TypedefTable::addToEnclosingScope2( kind_t kind ) {
    110         addToEnclosingScope2( nextIdentifiers.top(), kind );
    111 }
    112 
    113 void TypedefTable::setNextIdentifier( const std::string &identifier ) {
    114         nextIdentifiers.top() = identifier;
    115 }
    116 
    117 void TypedefTable::openTrait( const std::string &contextName ) {
    118         map< string, deferListType >::iterator i = contexts.find( contextName );
    119         if ( i != contexts.end() ) {
    120                 deferListType &entries = i->second;
    121                 for ( deferListType::iterator i = entries.begin(); i != entries.end(); i++) {
    122                         addToEnclosingScope( i->identifier, i->kind );
    123                 } // for
    124         } // if
    125 }
     60void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind ) {
     61        assert( kindTable.currentScope() >= 1 );
     62        auto scope = kindTable.currentScope() - 1;
     63        debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << endl );
     64        auto ret = kindTable.insertAt( scope, identifier, kind );
     65        if ( ! ret.second ) ret.first->second = kind;           // exists => update
     66} // TypedefTable::addToEnclosingScope
    12667
    12768void TypedefTable::enterScope() {
    128         currentScope += 1;
    129         deferListStack.push( deferListType() );
    130         nextIdentifiers.push( "" );
    131         debugPrint( "Entering scope " << currentScope << ", nextIdentifiers size is " << nextIdentifiers.size() << endl );
    132 }
     69        kindTable.beginScope();
     70        debugPrint( "Entering scope " << kindTable.currentScope() << endl );
     71} // TypedefTable::enterScope
    13372
    13473void TypedefTable::leaveScope() {
    135         debugPrint( "Leaving scope " << currentScope << endl );
    136         for ( tableType::iterator i = table.begin(); i != table.end(); ) {
    137                 list< Entry > &declList = (*i).second;
    138                 while ( ! declList.empty() && declList.front().scope == currentScope ) {
    139                         declList.pop_front();
    140                 }
    141                 if ( declList.empty() ) {                                               // standard idom for erasing during traversal
    142                         table.erase( i++ );
    143                 } else
    144                         ++i;
    145         } // for
    146         currentScope -= 1;
    147         for ( deferListType::iterator i = deferListStack.top().begin(); i != deferListStack.top().end(); i++ ) {
    148                 addToCurrentScope( i->identifier, i->kind );
    149         } // for
    150         deferListStack.pop();
    151         debugPrint( "nextIdentifiers size is " << nextIdentifiers.size() << " top is " << nextIdentifiers.top() << endl );
    152         nextIdentifiers.pop();
    153 }
     74        debugPrint( "Leaving scope " << kindTable.currentScope() << endl );
     75        kindTable.endScope();
     76} // TypedefTable::leaveScope
    15477
    155 void TypedefTable::enterTrait( const std::string &contextName ) {
    156         currentTrait = contextName;
    157         contextScope = currentScope;
    158 }
    159 
    160 void TypedefTable::leaveTrait() {
    161         currentTrait = "";
    162 }
    163 
    164 void TypedefTable::print( void ) const {
    165         for ( tableType::const_iterator i = table.begin(); i != table.end(); i++) {
    166                 debugPrint( (*i ).first << ": " );
    167                 list< Entry > declList = (*i).second;
    168                 for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
    169                         debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
    170                 }
    171                 debugPrint( endl );
    172         } // for
    173 }
     78// void TypedefTable::print( void ) const {
     79//      for ( KindTable::const_iterator i = table.begin(); i != table.end(); i++) {
     80//              debugPrint( (*i ).first << ": " );
     81//              list< Entry > declList = (*i).second;
     82//              for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
     83//                      debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
     84//              }
     85//              debugPrint( endl );
     86//      } // for
     87// }
    17488
    17589// Local Variables: //
  • src/Parser/TypedefTable.h

    r4a333d35 rcac8a6e  
    77// TypedefTable.h --
    88//
    9 // Author           : Rodolfo G. Esteves
     9// Author           : Peter A. Buhr
    1010// Created On       : Sat May 16 15:24:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:33:14 2017
    13 // Update Count     : 34
     12// Last Modified On : Tue May 22 08:39:29 2018
     13// Update Count     : 77
    1414//
    1515
    1616#pragma once
    1717
    18 #include <list>       // for list
    19 #include <map>        // for map, map<>::value_compare
    20 #include <stack>      // for stack
    21 #include <string>     // for string
     18#include <string>                                                                               // for string
    2219
     20#include "Common/ScopedMap.h"                                                   // for ScopedMap
    2321#include "ParserTypes.h"
    24 #include "parser.hh"  // for IDENTIFIER, TYPEDEFname, TYPEGENname
     22#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname
    2523
    2624class TypedefTable {
     25        typedef ScopedMap< std::string, int > KindTable;
     26        KindTable kindTable;   
    2727  public:
    28         enum kind_t { ID = IDENTIFIER, TD = TYPEDEFname, TG = TYPEGENname };
    29   private:
    30         struct Entry {
    31                 int scope;
    32                 kind_t kind;
    33         };
     28        ~TypedefTable();
    3429
    35         struct DeferredEntry {
    36                 std::string identifier;
    37                 kind_t kind;
    38         };
    39 
    40         typedef std::map< std::string, std::list< Entry > > tableType;
    41         tableType table;
    42 
    43         int currentScope;
    44         std::string currentTrait;
    45         int contextScope;
    46 
    47         typedef std::list< DeferredEntry > deferListType;
    48         std::stack< deferListType > deferListStack;
    49         std::map< std::string, deferListType > contexts;
    50 
    51         std::stack< std::string > nextIdentifiers;
    52 
    53         void addToScope( const std::string &identifier, kind_t kind, int scope );
    54   public:
    55         TypedefTable();
    56 
    57         bool exists( const std::string &identifier );
    58         int isKind( const std::string &identifier ) const;
    59         void changeKind( const std::string &identifier, kind_t kind );
    60 
    61         void makeTypedef( const std::string &name );
    62 
    63         // "addToCurrentScope" adds the identifier/type pair to the current scope. This does less than you think it does,
    64         // since each declaration is within its own scope.  Mostly useful for type parameters.
    65         void addToCurrentScope( const std::string &identifier, kind_t kind );
    66         void addToCurrentScope( kind_t kind );                  // use nextIdentifiers.top()
    67 
    68         // "addToEnclosingScope" adds the identifier/type pair to the scope that encloses the current one.  This is the
    69         // right way to handle type and typedef names
    70         void addToEnclosingScope( const std::string &identifier, kind_t kind );
    71         void addToEnclosingScope( kind_t kind );                // use nextIdentifiers.top()
    72 
    73         // "addToEnclosingScope2" adds the identifier/type pair to the scope that encloses the scope enclosing the the
    74         // current one.  This is the right way to handle assertion names
    75         void addToEnclosingScope2( const std::string &identifier, kind_t kind );
    76         void addToEnclosingScope2( kind_t kind );               // use nextIdentifiers.top()
    77 
    78         // set the next identifier to be used by an "add" operation without an identifier parameter within the current scope
    79         void setNextIdentifier( const std::string &identifier );
    80 
    81         // dump the definitions from a pre-defined context into the current scope
    82         void openTrait( const std::string &contextName );
     30        bool exists( const std::string & identifier );
     31        int isKind( const std::string & identifier ) const;
     32        void changeKind( const std::string & identifier, int kind );
     33        void makeTypedef( const std::string & name );
     34        void addToEnclosingScope( const std::string & identifier, int kind );
    8335
    8436        void enterScope();
    8537        void leaveScope();
    86         void enterTrait( const std::string &contextName );
    87         void leaveTrait();
    88 
    89         void print() const;
    90 };
     38}; // TypedefTable
    9139
    9240// Local Variables: //
  • src/Parser/parser.yy

    r4a333d35 rcac8a6e  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri May 11 17:51:38 2018
    13 // Update Count     : 3261
     12// Last Modified On : Tue May 22 08:41:57 2018
     13// Update Count     : 3353
    1414//
    1515
     
    119119// Does the forall bind to the struct or the routine, and how would it be possible to explicitly specify the binding.
    120120//   forall( otype T ) struct S { int T; } forall( otype W ) bar( W ) {}
     121// Currently, the forall is associated with the routine, and the generic type has to be separately defined:
     122//   forall( otype T ) struct S { int T; };
     123//   forall( otype W ) bar( W ) {}
    121124
    122125void rebindForall( DeclarationNode * declSpec, DeclarationNode * funcDecl ) {
    123         if ( declSpec->type->kind == TypeData::Aggregate ) { // return is aggregate definition
     126        if ( declSpec->type->kind == TypeData::Aggregate ) { // ignore aggregate definition
    124127                funcDecl->type->forall = declSpec->type->aggregate.params; // move forall from aggregate to function type
    125128                declSpec->type->aggregate.params = nullptr;
     
    301304%type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
    302305
    303 %type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
     306%type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
    304307%type<en> field field_list field_name fraction_constants_opt
    305308
     
    361364
    362365// initializers
    363 %type<in>  initializer initializer_list initializer_opt
     366%type<in>  initializer initializer_list_opt initializer_opt
    364367
    365368// designators
     
    412415// actions during the parser update this data structure when the class of identifiers change.
    413416//
    414 // Because the Cforall language is block-scoped, there is the possibility that an identifier can change its class in a
    415 // local scope; it must revert to its original class at the end of the block.  Since type names can be local to a
    416 // particular declaration, each declaration is itself a scope.  This requires distinguishing between type names that are
    417 // local to the current declaration scope and those that persist past the end of the declaration (i.e., names defined in
    418 // "typedef" or "otype" declarations).
    419 //
    420 // The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and closing of
    421 // scopes.  Every push must have a matching pop, although it is regrettable the matching pairs do not always occur
    422 // within the same rule.  These non-terminals may appear in more contexts than strictly necessary from a semantic point
    423 // of view.  Unfortunately, these extra rules are necessary to prevent parsing conflicts -- the parser may not have
    424 // enough context and look-ahead information to decide whether a new scope is necessary, so the effect of these extra
    425 // rules is to open a new scope unconditionally.  As the grammar evolves, it may be neccesary to add or move around
    426 // "push" and "pop" nonterminals to resolve conflicts of this sort.
     417// Because the Cforall language is block-scoped, an identifier can change its class in a local scope; it must revert to
     418// its original class at the end of the block.  Since type names can be local to a particular declaration, each
     419// declaration is itself a scope.  This requires distinguishing between type names that are local to the current
     420// declaration scope and those that persist past the end of the declaration (i.e., names defined in "typedef" or "otype"
     421// declarations).
     422//
     423// The non-terminals "push" and "pop" denote the opening and closing of scopes.  Every push must have a matching pop,
     424// although it is regrettable the matching pairs do not always occur within the same rule.  These non-terminals may
     425// appear in more contexts than strictly necessary from a semantic point of view.
    427426
    428427push:
     
    498497                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
    499498        | type_name '.' no_attr_identifier                                      // CFA, nested type
    500                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
    501 //              { $$ = nullptr; }
    502         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
    503                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
    504 //              { $$ = nullptr; }
     499                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
     500        | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
     501                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
    505502        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
    506503                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
     
    519516postfix_expression:
    520517        primary_expression
    521         | postfix_expression '[' push assignment_expression pop ']'
     518        | postfix_expression '[' assignment_expression ']'
    522519                // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
    523520                // matrix with x[i,j] instead of x[i][j]. While this change is not backwards compatible, there seems to be
    524521                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    525522                // equivalent to the old x[i,j].
    526                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
     523                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
    527524        | postfix_expression '{' argument_expression_list '}' // CFA, constructor call
    528525                {
     
    539536        | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
    540537                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
    541         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    542                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
     538        | postfix_expression '.' '[' field_list ']'                     // CFA, tuple field selector
     539                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    543540        | postfix_expression ARROW no_attr_identifier
    544541                {
     
    547544        | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
    548545                { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
    549         | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    550                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
     546        | postfix_expression ARROW '[' field_list ']'           // CFA, tuple field selector
     547                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
    551548        | postfix_expression ICR
    552549                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
    553550        | postfix_expression DECR
    554551                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
    555         | '(' type_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
     552        | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
    556553                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
    557         | '(' type_no_function ')' '@' '{' initializer_list comma_opt '}' // CFA, explicit C compound-literal
     554        | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
    558555                { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
    559556        | '^' primary_expression '{' argument_expression_list '}' // CFA
     
    588585        | FLOATING_DECIMALconstant field
    589586                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
    590         | FLOATING_DECIMALconstant '[' push field_list pop ']'
    591                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
     587        | FLOATING_DECIMALconstant '[' field_list ']'
     588                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
    592589        | field_name '.' field
    593590                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
    594         | field_name '.' '[' push field_list pop ']'
    595                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
     591        | field_name '.' '[' field_list ']'
     592                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
    596593        | field_name ARROW field
    597594                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
    598         | field_name ARROW '[' push field_list pop ']'
    599                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
     595        | field_name ARROW '[' field_list ']'
     596                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
    600597        ;
    601598
     
    807804        | unary_expression assignment_operator assignment_expression
    808805                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
    809         | unary_expression '=' '{' initializer_list comma_opt '}'
     806        | unary_expression '=' '{' initializer_list_opt comma_opt '}'
    810807                { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
    811808        ;
     
    840837//      '[' push assignment_expression pop ']'
    841838//              { $$ = new ExpressionNode( build_tuple( $3 ) ); }
    842         '[' push ',' tuple_expression_list pop ']'
    843                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $4 ) ) ); }
    844         | '[' push assignment_expression ',' tuple_expression_list pop ']'
    845                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $5 ) ) ); }
     839        '[' ',' tuple_expression_list ']'
     840                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $3 ) ) ); }
     841        | '[' assignment_expression ',' tuple_expression_list ']'
     842                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$2->set_last( $4 ) ) ); }
    846843        ;
    847844
     
    10741071        | RETURN comma_expression_opt ';'
    10751072                { $$ = new StatementNode( build_return( $2 ) ); }
    1076         | RETURN '{' initializer_list comma_opt '}'
     1073        | RETURN '{' initializer_list_opt comma_opt '}'
    10771074                { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
    10781075        | THROW assignment_expression_opt ';'                           // handles rethrow
     
    11681165
    11691166handler_predicate_opt:
    1170         //empty
     1167        // empty
    11711168                { $$ = nullptr; }
    11721169        | ';' conditional_expression                            { $$ = $2; }
     
    11871184        | type_specifier_nobody declarator
    11881185                {
    1189                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    11901186                        $$ = $2->addType( $1 );
    11911187                }
     
    11941190        | cfa_abstract_declarator_tuple no_attr_identifier      // CFA
    11951191                {
    1196                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    11971192                        $$ = $1->addName( $2 );
    11981193                }
     
    13441339cfa_variable_declaration:                                                               // CFA
    13451340        cfa_variable_specifier initializer_opt
    1346                 {
    1347                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1348                         $$ = $1->addInitializer( $2 );
    1349                 }
     1341                { $$ = $1->addInitializer( $2 ); }
    13501342        | declaration_qualifier_list cfa_variable_specifier initializer_opt
    13511343                // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to preclude
    13521344                // them as a type_qualifier cannot appear in that context.
    1353                 {
    1354                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1355                         $$ = $2->addQualifiers( $1 )->addInitializer( $3 );;
    1356                 }
     1345                { $$ = $2->addQualifiers( $1 )->addInitializer( $3 ); }
    13571346        | cfa_variable_declaration pop ',' push identifier_or_type_name initializer_opt
    1358                 {
    1359                         typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
    1360                         $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) );
    1361                 }
     1347                { $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) ); }
    13621348        ;
    13631349
     
    13661352                // storage-class
    13671353        cfa_abstract_declarator_no_tuple identifier_or_type_name asm_name_opt
    1368                 {
    1369                         typedefTable.setNextIdentifier( *$2 );
    1370                         $$ = $1->addName( $2 )->addAsmName( $3 );
    1371                 }
     1354                { $$ = $1->addName( $2 )->addAsmName( $3 ); }
    13721355        | cfa_abstract_tuple identifier_or_type_name asm_name_opt
    1373                 {
    1374                         typedefTable.setNextIdentifier( *$2 );
    1375                         $$ = $1->addName( $2 )->addAsmName( $3 );
    1376                 }
     1356                { $$ = $1->addName( $2 )->addAsmName( $3 ); }
    13771357        | type_qualifier_list cfa_abstract_tuple identifier_or_type_name asm_name_opt
    1378                 {
    1379                         typedefTable.setNextIdentifier( *$3 );
    1380                         $$ = $2->addQualifiers( $1 )->addName( $3 )->addAsmName( $4 );
    1381                 }
     1358                { $$ = $2->addQualifiers( $1 )->addName( $3 )->addAsmName( $4 ); }
    13821359        ;
    13831360
    13841361cfa_function_declaration:                                                               // CFA
    13851362        cfa_function_specifier
    1386                 {
    1387                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1388                         $$ = $1;
    1389                 }
     1363                { $$ = $1; }
    13901364        | type_qualifier_list cfa_function_specifier
    1391                 {
    1392                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1393                         $$ = $2->addQualifiers( $1 );
    1394                 }
     1365                { $$ = $2->addQualifiers( $1 ); }
    13951366        | declaration_qualifier_list cfa_function_specifier
    1396                 {
    1397                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1398                         $$ = $2->addQualifiers( $1 );
    1399                 }
     1367                { $$ = $2->addQualifiers( $1 ); }
    14001368        | declaration_qualifier_list type_qualifier_list cfa_function_specifier
    1401                 {
    1402                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1403                         $$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
    1404                 }
    1405         | cfa_function_declaration pop ',' push identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
     1369                { $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); }
     1370        | cfa_function_declaration ',' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
    14061371                {
    14071372                        // Append the return type at the start (left-hand-side) to each identifier in the list.
    14081373                        DeclarationNode * ret = new DeclarationNode;
    14091374                        ret->type = maybeClone( $1->type->base );
    1410                         $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr ) );
     1375                        $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $5, nullptr ) );
    14111376                }
    14121377        ;
     
    14351400                // type_specifier can resolve to just TYPEDEFname (e.g., typedef int T; int f( T );). Therefore this must be
    14361401                // flattened to allow lookahead to the '(' without having to reduce identifier_or_type_name.
    1437         cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
     1402        cfa_abstract_tuple identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
    14381403                // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
    1439                 {
    1440                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
    1441                 }
    1442         | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
    1443                 {
    1444                         $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
    1445                 }
     1404                { $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); }
     1405        | cfa_function_return identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
     1406                { $$ = DeclarationNode::newFunction( $2, $1, $4, 0 ); }
    14461407        ;
    14471408
    14481409cfa_function_return:                                                                    // CFA
    1449         '[' push cfa_parameter_list pop ']'
    1450                 { $$ = DeclarationNode::newTuple( $3 ); }
    1451         | '[' push cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ']'
     1410        '[' cfa_parameter_list ']'
     1411                { $$ = DeclarationNode::newTuple( $2 ); }
     1412        | '[' cfa_parameter_list ',' cfa_abstract_parameter_list ']'
    14521413                // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the
    14531414                // ']'.
    1454                 { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
     1415                { $$ = DeclarationNode::newTuple( $2->appendList( $4 ) ); }
    14551416        ;
    14561417
     
    14581419        TYPEDEF cfa_variable_specifier
    14591420                {
    1460                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1421                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
    14611422                        $$ = $2->addTypedef();
    14621423                }
    14631424        | TYPEDEF cfa_function_specifier
    14641425                {
    1465                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1426                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
    14661427                        $$ = $2->addTypedef();
    14671428                }
    14681429        | cfa_typedef_declaration pop ',' push no_attr_identifier
    14691430                {
    1470                         typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
     1431                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname );
    14711432                        $$ = $1->appendList( $1->cloneType( $5 ) );
    14721433                }
     
    14791440        TYPEDEF type_specifier declarator
    14801441                {
    1481                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1442                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
    14821443                        $$ = $3->addType( $2 )->addTypedef();
    14831444                }
    14841445        | typedef_declaration pop ',' push declarator
    14851446                {
    1486                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1447                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname );
    14871448                        $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
    14881449                }
    14891450        | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
    14901451                {
    1491                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1452                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
    14921453                        $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
    14931454                }
    14941455        | type_specifier TYPEDEF declarator
    14951456                {
    1496                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1457                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
    14971458                        $$ = $3->addType( $1 )->addTypedef();
    14981459                }
    14991460        | type_specifier TYPEDEF type_qualifier_list declarator
    15001461                {
    1501                         typedefTable.addToEnclosingScope( TypedefTable::TD );
     1462                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
    15021463                        $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
    15031464                }
     
    15081469        TYPEDEF no_attr_identifier '=' assignment_expression
    15091470                {
    1510                         typedefTable.addToEnclosingScope( *$2, TypedefTable::TD );
    1511                         $$ = DeclarationNode::newName( 0 );                     // unimplemented
     1471                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
     1472                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
    15121473                }
    15131474        | typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
    15141475                {
    1515                         typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
    1516                         $$ = DeclarationNode::newName( 0 );                     // unimplemented
     1476                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
     1477                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
    15171478                }
    15181479        ;
     
    15301491//       declarator asm_name_opt initializer_opt
    15311492//              {
    1532 //                      typedefTable.addToEnclosingScope( TypedefTable::ID );
     1493//                      typedefTable.addToEnclosingScope( IDENTIFIER );
    15331494//                      $$ = ( $2->addType( $1 ))->addAsmName( $3 )->addInitializer( $4 );
    15341495//              }
    15351496//      | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
    15361497//              {
    1537 //                      typedefTable.addToEnclosingScope( TypedefTable::ID );
     1498//                      typedefTable.addToEnclosingScope( IDENTIFIER );
    15381499//                      $$ = $1->appendList( $1->cloneBaseType( $4->addAsmName( $5 )->addInitializer( $6 ) ) );
    15391500//              }
     
    15421503c_declaration:
    15431504        declaration_specifier declaring_list
    1544                 {
    1545                         $$ = distAttr( $1, $2 );
    1546                 }
     1505                { $$ = distAttr( $1, $2 ); }
    15471506        | typedef_declaration
    15481507        | typedef_expression                                                            // GCC, naming expression type
     
    15541513                // storage-class
    15551514        declarator asm_name_opt initializer_opt
    1556                 {
    1557                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1558                         $$ = $1->addAsmName( $2 )->addInitializer( $3 );
    1559                 }
     1515                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
    15601516        | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
    1561                 {
    1562                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    1563                         $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) );
    1564                 }
     1517                { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
    15651518        ;
    15661519
     
    18541807
    18551808aggregate_type:                                                                                 // struct, union
    1856         aggregate_key attribute_list_opt '{' field_declaration_list '}'
     1809        aggregate_key attribute_list_opt '{' field_declaration_list_opt '}'
    18571810                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
    18581811        | aggregate_key attribute_list_opt no_attr_identifier_or_type_name
    18591812                {
    18601813                        typedefTable.makeTypedef( *$3 );                        // create typedef
    1861                         if ( forall ) typedefTable.changeKind( *$3, TypedefTable::TG ); // possibly update
     1814                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
    18621815                        forall = false;                                                         // reset
    18631816                }
    1864           '{' field_declaration_list '}'
     1817          '{' field_declaration_list_opt '}'
    18651818                { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
    1866         | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list '}' // CFA
     1819        | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list_opt '}' // CFA
    18671820                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
    18681821        | aggregate_type_nobody
     
    18731826                {
    18741827                        typedefTable.makeTypedef( *$3 );
    1875                         if ( forall ) typedefTable.changeKind( *$3, TypedefTable::TG ); // possibly update
     1828                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
    18761829                        forall = false;                                                         // reset
    18771830                        $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
     
    19091862        ;
    19101863
    1911 field_declaration_list:
     1864field_declaration_list_opt:
    19121865        // empty
    19131866                { $$ = nullptr; }
    1914         | field_declaration_list field_declaration
     1867        | field_declaration_list_opt field_declaration
    19151868                { $$ = $1 ? $1->appendList( $2 ) : $2; }
    19161869        ;
     
    19451898
    19461899field_declaring_list:
    1947         field_declarator
    1948         | field_declaring_list ',' attribute_list_opt field_declarator
     1900        field_declarator_opt
     1901        | field_declaring_list ',' attribute_list_opt field_declarator_opt
    19491902                { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
    19501903        ;
    19511904
    1952 field_declarator:
     1905field_declarator_opt:
    19531906        // empty
    19541907                { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
     
    20171970        | cfa_abstract_parameter_list
    20181971        | cfa_parameter_list
    2019         | cfa_parameter_list pop ',' push cfa_abstract_parameter_list
    2020                 { $$ = $1->appendList( $5 ); }
    2021         | cfa_abstract_parameter_list pop ',' push ELLIPSIS
     1972        | cfa_parameter_list ',' cfa_abstract_parameter_list
     1973                { $$ = $1->appendList( $3 ); }
     1974        | cfa_abstract_parameter_list ',' ELLIPSIS
    20221975                { $$ = $1->addVarArgs(); }
    2023         | cfa_parameter_list pop ',' push ELLIPSIS
     1976        | cfa_parameter_list ',' ELLIPSIS
    20241977                { $$ = $1->addVarArgs(); }
    20251978        ;
     
    20291982                // factored out from cfa_parameter_list, flattening the rules to get lookahead to the ']'.
    20301983        cfa_parameter_declaration
    2031         | cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
    2032                 { $$ = $1->appendList( $5 ); }
    2033         | cfa_parameter_list pop ',' push cfa_parameter_declaration
    2034                 { $$ = $1->appendList( $5 ); }
    2035         | cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ',' push cfa_parameter_declaration
    2036                 { $$ = $1->appendList( $5 )->appendList( $9 ); }
     1984        | cfa_abstract_parameter_list ',' cfa_parameter_declaration
     1985                { $$ = $1->appendList( $3 ); }
     1986        | cfa_parameter_list ',' cfa_parameter_declaration
     1987                { $$ = $1->appendList( $3 ); }
     1988        | cfa_parameter_list ',' cfa_abstract_parameter_list ',' cfa_parameter_declaration
     1989                { $$ = $1->appendList( $3 )->appendList( $5 ); }
    20371990        ;
    20381991
    20391992cfa_abstract_parameter_list:                                                    // CFA, new & old style abstract
    20401993        cfa_abstract_parameter_declaration
    2041         | cfa_abstract_parameter_list pop ',' push cfa_abstract_parameter_declaration
    2042                 { $$ = $1->appendList( $5 ); }
     1994        | cfa_abstract_parameter_list ',' cfa_abstract_parameter_declaration
     1995                { $$ = $1->appendList( $3 ); }
    20431996        ;
    20441997
     
    20902043                // No SUE declaration in parameter list.
    20912044        declaration_specifier_nobody identifier_parameter_declarator default_initialize_opt
    2092                 {
    2093                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    2094                         $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
    2095                 }
     2045                { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
    20962046        | declaration_specifier_nobody type_parameter_redeclarator default_initialize_opt
    2097                 {
    2098                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    2099                         $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
    2100                 }
     2047                { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
    21012048        ;
    21022049
     
    21562103initializer:
    21572104        assignment_expression                                           { $$ = new InitializerNode( $1 ); }
    2158         | '{' initializer_list comma_opt '}'            { $$ = new InitializerNode( $2, true ); }
    2159         ;
    2160 
    2161 initializer_list:
     2105        | '{' initializer_list_opt comma_opt '}'        { $$ = new InitializerNode( $2, true ); }
     2106        ;
     2107
     2108initializer_list_opt:
    21622109        // empty
    21632110                { $$ = nullptr; }
    21642111        | initializer
    21652112        | designation initializer                                       { $$ = $2->set_designators( $1 ); }
    2166         | initializer_list ',' initializer                      { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
    2167         | initializer_list ',' designation initializer
     2113        | initializer_list_opt ',' initializer          { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
     2114        | initializer_list_opt ',' designation initializer
    21682115                { $$ = (InitializerNode *)( $1->set_last( $4->set_designators( $3 ) ) ); }
    21692116        ;
     
    21952142        '.' no_attr_identifier                                                          // C99, field name
    21962143                { $$ = new ExpressionNode( build_varref( $2 ) ); }
    2197         | '[' push assignment_expression pop ']'                        // C99, single array element
     2144        | '[' assignment_expression ']'                                         // C99, single array element
    21982145                // assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple.
     2146                { $$ = $2; }
     2147        | '[' subrange ']'                                                                      // CFA, multiple array elements
     2148                { $$ = $2; }
     2149        | '[' constant_expression ELLIPSIS constant_expression ']' // GCC, multiple array elements
     2150                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $2 ), maybeMoveBuild< Expression >( $4 ) ) ); }
     2151        | '.' '[' field_list ']'                                                        // CFA, tuple field selector
    21992152                { $$ = $3; }
    2200         | '[' push subrange pop ']'                                                     // CFA, multiple array elements
    2201                 { $$ = $3; }
    2202         | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    2203                 { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); }
    2204         | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    2205                 { $$ = $4; }
    22062153        ;
    22072154
     
    22402187type_parameter:                                                                                 // CFA
    22412188        type_class no_attr_identifier_or_type_name
    2242                 { typedefTable.addToEnclosingScope( *$2, TypedefTable::TD ); }
     2189                { typedefTable.addToEnclosingScope( *$2, TYPEDEFname ); }
    22432190          type_initializer_opt assertion_list_opt
    22442191                { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
     
    22732220assertion:                                                                                              // CFA
    22742221        '|' no_attr_identifier_or_type_name '(' type_list ')'
    2275                 {
    2276                         typedefTable.openTrait( *$2 );
    2277                         $$ = DeclarationNode::newTraitUse( $2, $4 );
    2278                 }
     2222                { $$ = DeclarationNode::newTraitUse( $2, $4 ); }
    22792223        | '|' '{' push trait_declaration_list '}'
    22802224                { $$ = $4; }
    22812225        | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
    2282                 { $$ = nullptr; }
     2226                { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
    22832227        ;
    22842228
     
    23122256        no_attr_identifier_or_type_name
    23132257                {
    2314                         typedefTable.addToEnclosingScope( *$1, TypedefTable::TD );
     2258                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname );
    23152259                        $$ = DeclarationNode::newTypeDecl( $1, 0 );
    23162260                }
    23172261        | no_attr_identifier_or_type_name '(' push type_parameter_list pop ')'
    23182262                {
    2319                         typedefTable.addToEnclosingScope( *$1, TypedefTable::TG );
     2263                        typedefTable.addToEnclosingScope( *$1, TYPEGENname );
    23202264                        $$ = DeclarationNode::newTypeDecl( $1, $4 );
    23212265                }
     
    23242268trait_specifier:                                                                                // CFA
    23252269        TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}'
    2326                 {
    2327                         typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
    2328                         $$ = DeclarationNode::newTrait( $2, $5, 0 );
    2329                 }
     2270                { $$ = DeclarationNode::newTrait( $2, $5, 0 ); }
    23302271        | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{'
    2331                 {
    2332                         typedefTable.enterTrait( *$2 );
    2333                         typedefTable.enterScope();
    2334                 }
     2272                { typedefTable.enterScope(); }
    23352273          trait_declaration_list '}'
    2336                 {
    2337                         typedefTable.leaveTrait();
    2338                         typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
    2339                         $$ = DeclarationNode::newTrait( $2, $5, $10 );
    2340                 }
     2274                { $$ = DeclarationNode::newTrait( $2, $5, $10 ); }
    23412275        ;
    23422276
     
    23542288cfa_trait_declaring_list:                                                               // CFA
    23552289        cfa_variable_specifier
    2356                 {
    2357                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
    2358                         $$ = $1;
    2359                 }
     2290                { $$ = $1; }
    23602291        | cfa_function_specifier
    2361                 {
    2362                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
    2363                         $$ = $1;
    2364                 }
     2292                { $$ = $1; }
    23652293        | cfa_trait_declaring_list pop ',' push identifier_or_type_name
    2366                 {
    2367                         typedefTable.addToEnclosingScope2( *$5, TypedefTable::ID );
    2368                         $$ = $1->appendList( $1->cloneType( $5 ) );
    2369                 }
     2294                { $$ = $1->appendList( $1->cloneType( $5 ) ); }
    23702295        ;
    23712296
    23722297trait_declaring_list:                                                                   // CFA
    23732298        type_specifier declarator
    2374                 {
    2375                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
    2376                         $$ = $2->addType( $1 );
    2377                 }
     2299                { $$ = $2->addType( $1 ); }
    23782300        | trait_declaring_list pop ',' push declarator
    2379                 {
    2380                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
    2381                         $$ = $1->appendList( $1->cloneBaseType( $5 ) );
    2382                 }
     2301                { $$ = $1->appendList( $1->cloneBaseType( $5 ) ); }
    23832302        ;
    23842303
     
    24882407        | function_declarator compound_statement
    24892408                {
    2490                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    24912409                        typedefTable.leaveScope();
    24922410                        $$ = $1->addFunctionBody( $2 );
     
    24942412        | KR_function_declarator KR_declaration_list_opt compound_statement
    24952413                {
    2496                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    24972414                        typedefTable.leaveScope();
    24982415                        $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 );
     
    25102427        cfa_function_declaration with_clause_opt compound_statement     // CFA
    25112428                {
    2512                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25132429                        typedefTable.leaveScope();
    25142430                        // Add the function body to the last identifier in the function definition list, i.e., foo3:
     
    25202436                {
    25212437                        rebindForall( $1, $2 );
    2522                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25232438                        typedefTable.leaveScope();
    25242439                        $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
    25252440                }
     2441        | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
     2442                {
     2443                        rebindForall( $1, $2 );
     2444                        typedefTable.leaveScope();
     2445                        $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
     2446                }
    25262447                // handles default int return type, OBSOLESCENT (see 1)
    25272448        | type_qualifier_list function_declarator with_clause_opt compound_statement
    25282449                {
    2529                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25302450                        typedefTable.leaveScope();
    25312451                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
     
    25342454        | declaration_qualifier_list function_declarator with_clause_opt compound_statement
    25352455                {
    2536                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25372456                        typedefTable.leaveScope();
    25382457                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
     
    25412460        | declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement
    25422461                {
    2543                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25442462                        typedefTable.leaveScope();
    25452463                        $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 );
     
    25502468                {
    25512469                        rebindForall( $1, $2 );
    2552                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25532470                        typedefTable.leaveScope();
    25542471                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addType( $1 );
     
    25572474        | type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
    25582475                {
    2559                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25602476                        typedefTable.leaveScope();
    25612477                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
     
    25642480        | declaration_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
    25652481                {
    2566                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25672482                        typedefTable.leaveScope();
    25682483                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
     
    25712486        | declaration_qualifier_list type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
    25722487                {
    2573                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    25742488                        typedefTable.leaveScope();
    25752489                        $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 );
     
    26842598paren_identifier:
    26852599        identifier
    2686                 {
    2687                         typedefTable.setNextIdentifier( *$1 );
    2688                         $$ = DeclarationNode::newName( $1 );
    2689                 }
     2600                { $$ = DeclarationNode::newName( $1 ); }
    26902601        | '(' paren_identifier ')'                                                      // redundant parenthesis
    26912602                { $$ = $2; }
     
    27742685        paren_identifier '(' identifier_list ')'                        // function_declarator handles empty parameter
    27752686                { $$ = $1->addIdList( $3 ); }
    2776         | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
    2777                 { $$ = $2->addParamList( $6 ); }
     2687        | '(' KR_function_ptr ')' '(' parameter_type_list_opt ')'
     2688                { $$ = $2->addParamList( $5 ); }
    27782689        | '(' KR_function_no_ptr ')'                                            // redundant parenthesis
    27792690                { $$ = $2; }
     
    28202731paren_type:
    28212732        typedef
     2733                // hide type name in enclosing scope by variable name
     2734                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER ); }
    28222735        | '(' paren_type ')'
    28232736                { $$ = $2; }
     
    28912804
    28922805identifier_parameter_function:
    2893         paren_identifier '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    2894                 { $$ = $1->addParamList( $4 ); }
    2895         | '(' identifier_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    2896                 { $$ = $2->addParamList( $6 ); }
     2806        paren_identifier '(' parameter_type_list_opt ')'        // empty parameter list OBSOLESCENT (see 3)
     2807                { $$ = $1->addParamList( $3 ); }
     2808        | '(' identifier_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
     2809                { $$ = $2->addParamList( $5 ); }
    28972810        | '(' identifier_parameter_function ')'                         // redundant parenthesis
    28982811                { $$ = $2; }
     
    29222835typedef:
    29232836        TYPEDEFname
    2924                 {
    2925                         typedefTable.setNextIdentifier( *$1 );
    2926                         $$ = DeclarationNode::newName( $1 );
    2927                 }
     2837                { $$ = DeclarationNode::newName( $1 ); }
    29282838        | TYPEGENname
    2929                 {
    2930                         typedefTable.setNextIdentifier( *$1 );
    2931                         $$ = DeclarationNode::newName( $1 );
    2932                 }
     2839                { $$ = DeclarationNode::newName( $1 ); }
    29332840        ;
    29342841
     
    29502857
    29512858type_parameter_function:
    2952         typedef '(' push parameter_type_list_opt pop ')'        // empty parameter list OBSOLESCENT (see 3)
    2953                 { $$ = $1->addParamList( $4 ); }
    2954         | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    2955                 { $$ = $2->addParamList( $6 ); }
     2859        typedef '(' parameter_type_list_opt ')'                         // empty parameter list OBSOLESCENT (see 3)
     2860                { $$ = $1->addParamList( $3 ); }
     2861        | '(' type_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
     2862                { $$ = $2->addParamList( $5 ); }
    29562863        ;
    29572864
     
    30002907
    30012908abstract_function:
    3002         '(' push parameter_type_list_opt pop ')'                        // empty parameter list OBSOLESCENT (see 3)
    3003                 { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
    3004         | '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    3005                 { $$ = $2->addParamList( $6 ); }
     2909        '(' parameter_type_list_opt ')'                                         // empty parameter list OBSOLESCENT (see 3)
     2910                { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
     2911        | '(' abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
     2912                { $$ = $2->addParamList( $5 ); }
    30062913        | '(' abstract_function ')'                                                     // redundant parenthesis
    30072914                { $$ = $2; }
     
    30182925
    30192926multi_array_dimension:
    3020         '[' push assignment_expression pop ']'
    3021                 { $$ = DeclarationNode::newArray( $3, 0, false ); }
    3022         | '[' push '*' pop ']'                                                          // C99
     2927        '[' assignment_expression ']'
     2928                { $$ = DeclarationNode::newArray( $2, 0, false ); }
     2929        | '[' '*' ']'                                                                           // C99
    30232930                { $$ = DeclarationNode::newVarArray( 0 ); }
    3024         | multi_array_dimension '[' push assignment_expression pop ']'
    3025                 { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); }
    3026         | multi_array_dimension '[' push '*' pop ']'            // C99
     2931        | multi_array_dimension '[' assignment_expression ']'
     2932                { $$ = $1->addArray( DeclarationNode::newArray( $3, 0, false ) ); }
     2933        | multi_array_dimension '[' '*' ']'                                     // C99
    30272934                { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); }
    30282935        ;
     
    30912998
    30922999abstract_parameter_function:
    3093         '(' push parameter_type_list_opt pop ')'                        // empty parameter list OBSOLESCENT (see 3)
    3094                 { $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
    3095         | '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    3096                 { $$ = $2->addParamList( $6 ); }
     3000        '(' parameter_type_list_opt ')'                                         // empty parameter list OBSOLESCENT (see 3)
     3001                { $$ = DeclarationNode::newFunction( nullptr, nullptr, $2, nullptr ); }
     3002        | '(' abstract_parameter_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
     3003                { $$ = $2->addParamList( $5 ); }
    30973004        | '(' abstract_parameter_function ')'                           // redundant parenthesis
    30983005                { $$ = $2; }
     
    31163023                { $$ = DeclarationNode::newArray( 0, 0, false ); }
    31173024        // multi_array_dimension handles the '[' '*' ']' case
    3118         | '[' push type_qualifier_list '*' pop ']'                      // remaining C99
    3119                 { $$ = DeclarationNode::newVarArray( $3 ); }
    3120         | '[' push type_qualifier_list pop ']'
    3121                 { $$ = DeclarationNode::newArray( 0, $3, false ); }
     3025        | '[' type_qualifier_list '*' ']'                                       // remaining C99
     3026                { $$ = DeclarationNode::newVarArray( $2 ); }
     3027        | '[' type_qualifier_list ']'
     3028                { $$ = DeclarationNode::newArray( 0, $2, false ); }
    31223029        // multi_array_dimension handles the '[' assignment_expression ']' case
    3123         | '[' push type_qualifier_list assignment_expression pop ']'
    3124                 { $$ = DeclarationNode::newArray( $4, $3, false ); }
    3125         | '[' push STATIC type_qualifier_list_opt assignment_expression pop ']'
    3126                 { $$ = DeclarationNode::newArray( $5, $4, true ); }
    3127         | '[' push type_qualifier_list STATIC assignment_expression pop ']'
    3128                 { $$ = DeclarationNode::newArray( $5, $3, true ); }
     3030        | '[' type_qualifier_list assignment_expression ']'
     3031                { $$ = DeclarationNode::newArray( $3, $2, false ); }
     3032        | '[' STATIC type_qualifier_list_opt assignment_expression ']'
     3033                { $$ = DeclarationNode::newArray( $4, $3, true ); }
     3034        | '[' type_qualifier_list STATIC assignment_expression ']'
     3035                { $$ = DeclarationNode::newArray( $4, $2, true ); }
    31293036        ;
    31303037
     
    31703077
    31713078variable_abstract_function:
    3172         '(' variable_abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
    3173                 { $$ = $2->addParamList( $6 ); }
     3079        '(' variable_abstract_ptr ')' '(' parameter_type_list_opt ')' // empty parameter list OBSOLESCENT (see 3)
     3080                { $$ = $2->addParamList( $5 ); }
    31743081        | '(' variable_abstract_function ')'                            // redundant parenthesis
    31753082                { $$ = $2; }
     
    32343141
    32353142cfa_array_parameter_1st_dimension:
    3236         '[' push type_qualifier_list '*' pop ']'                        // remaining C99
    3237                 { $$ = DeclarationNode::newVarArray( $3 ); }
    3238         | '[' push type_qualifier_list assignment_expression pop ']'
    3239                 { $$ = DeclarationNode::newArray( $4, $3, false ); }
    3240         | '[' push declaration_qualifier_list assignment_expression pop ']'
     3143        '[' type_qualifier_list '*' ']'                                         // remaining C99
     3144                { $$ = DeclarationNode::newVarArray( $2 ); }
     3145        | '[' type_qualifier_list assignment_expression ']'
     3146                { $$ = DeclarationNode::newArray( $3, $2, false ); }
     3147        | '[' declaration_qualifier_list assignment_expression ']'
    32413148                // declaration_qualifier_list must be used because of shift/reduce conflict with
    32423149                // assignment_expression, so a semantic check is necessary to preclude them as a type_qualifier cannot
    32433150                // appear in this context.
    3244                 { $$ = DeclarationNode::newArray( $4, $3, true ); }
    3245         | '[' push declaration_qualifier_list type_qualifier_list assignment_expression pop ']'
    3246                 { $$ = DeclarationNode::newArray( $5, $4->addQualifiers( $3 ), true ); }
     3151                { $$ = DeclarationNode::newArray( $3, $2, true ); }
     3152        | '[' declaration_qualifier_list type_qualifier_list assignment_expression ']'
     3153                { $$ = DeclarationNode::newArray( $4, $3->addQualifiers( $3 ), true ); }
    32473154        ;
    32483155
     
    33133220
    33143221cfa_abstract_tuple:                                                                             // CFA
    3315         '[' push cfa_abstract_parameter_list pop ']'
    3316                 { $$ = DeclarationNode::newTuple( $3 ); }
     3222        '[' cfa_abstract_parameter_list ']'
     3223                { $$ = DeclarationNode::newTuple( $2 ); }
    33173224        ;
    33183225
     
    33203227//      '[' ']' '(' cfa_parameter_type_list_opt ')'
    33213228//              { $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
    3322         cfa_abstract_tuple '(' push cfa_parameter_type_list_opt pop ')'
    3323                 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
    3324         | cfa_function_return '(' push cfa_parameter_type_list_opt pop ')'
    3325                 { $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
     3229        cfa_abstract_tuple '(' cfa_parameter_type_list_opt ')'
     3230                { $$ = DeclarationNode::newFunction( nullptr, $1, $3, nullptr ); }
     3231        | cfa_function_return '(' cfa_parameter_type_list_opt ')'
     3232                { $$ = DeclarationNode::newFunction( nullptr, $1, $3, nullptr ); }
    33263233        ;
    33273234
  • src/ResolvExpr/AlternativeFinder.cc

    r4a333d35 rcac8a6e  
    12851285                AlternativeFinder finder( indexer, env );
    12861286                finder.targetType = toType;
    1287                 finder.findWithAdjustment( castExpr->get_arg() );
     1287                finder.findWithAdjustment( castExpr->arg );
    12881288
    12891289                AltList candidates;
     
    12961296                        // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
    12971297                        // to.
    1298                         int discardedValues = alt.expr->get_result()->size() - castExpr->get_result()->size();
     1298                        int discardedValues = alt.expr->result->size() - castExpr->result->size();
    12991299                        if ( discardedValues < 0 ) continue;
    13001300                        // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
    13011301                        // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
    13021302                        // unification run for side-effects
    1303                         unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions,
     1303                        unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
    13041304                                haveAssertions, openVars, indexer );
    1305                         Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer,
     1305                        Cost thisCost = castCost( alt.expr->result, castExpr->result, indexer,
    13061306                                alt.env );
    13071307                        PRINT(
     
    17261726                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
    17271727                                // unification run for side-effects
    1728                                 unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
     1728                                unify( toType, alt.expr->result, newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
    17291729
    17301730                                Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
  • src/ResolvExpr/Resolver.cc

    r4a333d35 rcac8a6e  
    127127
    128128        namespace {
    129                 void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
     129                struct StripCasts {
     130                        Expression * postmutate( CastExpr * castExpr ) {
     131                                if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
     132                                        // generated cast is to the same type as its argument, so it's unnecessary -- remove it
     133                                        Expression * expr = castExpr->arg;
     134                                        castExpr->arg = nullptr;
     135                                        std::swap( expr->env, castExpr->env );
     136                                        return expr;
     137                                }
     138                                return castExpr;
     139                        }
     140
     141                        static void strip( Expression *& expr ) {
     142                                PassVisitor<StripCasts> stripper;
     143                                expr = expr->acceptMutator( stripper );
     144                        }
     145                };
     146
     147                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
    130148                        expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
    131                         env.makeSubstitution( *expr->get_env() );
     149                        env.makeSubstitution( *expr->env );
     150                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
    132151                }
    133152
     
    414433
    415434        void Resolver::previsit( CaseStmt *caseStmt ) {
    416                 if ( caseStmt->get_condition() ) {
     435                if ( caseStmt->condition ) {
    417436                        std::list< InitAlternative > initAlts = currentObject.getOptions();
    418437                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
     
    420439                        Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
    421440                        findSingleExpression( newExpr, indexer );
    422                         CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
    423                         caseStmt->condition = castExpr->arg;
    424                         castExpr->arg = nullptr;
    425                         delete castExpr;
     441                        // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
     442                        // Ideally we would perform the conversion internally here.
     443                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
     444                                newExpr = castExpr->arg;
     445                                castExpr->arg = nullptr;
     446                                std::swap( newExpr->env, castExpr->env );
     447                                delete castExpr;
     448                        }
     449                        caseStmt->condition = newExpr;
    426450                }
    427451        }
     
    718742                initExpr->expr = nullptr;
    719743                std::swap( initExpr->env, newExpr->env );
    720                 std::swap( initExpr->inferParams, newExpr->inferParams ) ;
     744                // InitExpr may have inferParams in the case where the expression specializes a function pointer,
     745                // and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
     746                newExpr->spliceInferParams( initExpr );
    721747                delete initExpr;
    722748
  • src/ResolvExpr/TypeEnvironment.h

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

    r4a333d35 rcac8a6e  
    324324                } else if ( isopen1 ) {
    325325                        result = bindVar( var1, type2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    326                 } else if ( isopen2 ) {
     326                } else if ( isopen2 ) { // TODO: swap widenMode values in call, since type positions are flipped?
    327327                        result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    328328                } else {
  • src/SymTab/Indexer.cc

    r4a333d35 rcac8a6e  
    2626#include "Common/SemanticError.h"  // for SemanticError
    2727#include "Common/utility.h"        // for cloneAll
     28#include "GenPoly/GenPoly.h"
    2829#include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
    2930#include "Mangler.h"               // for Mangler
     
    377378        }
    378379
     380        bool isFunction( DeclarationWithType * decl ) {
     381                return GenPoly::getFunctionType( decl->get_type() );
     382        }
     383
     384        bool isObject( DeclarationWithType * decl ) {
     385                return ! isFunction( decl );
     386        }
     387
     388        bool isDefinition( DeclarationWithType * decl ) {
     389                if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
     390                        // a function is a definition if it has a body
     391                        return func->statements;
     392                } else {
     393                        // an object is a definition if it is not marked extern.
     394                        // both objects must be marked extern
     395                        return ! decl->get_storageClasses().is_extern;
     396                }
     397        }
     398
    379399        bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
    380400                // if we're giving the same name mangling to things of different types then there is something wrong
    381                 assert( (dynamic_cast<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing.id ) )
    382                         || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing.id ) ) );
     401                assert( (isObject( added ) && isObject( existing.id ) )
     402                        || ( isFunction( added ) && isFunction( existing.id ) ) );
    383403
    384404                if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
     
    394414                        }
    395415
    396                         // typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
    397                         // we should ignore outermost pointer qualifiers, except _Atomic?
    398                         FunctionDecl * newentry = dynamic_cast< FunctionDecl * >( added );
    399                         FunctionDecl * oldentry = dynamic_cast< FunctionDecl * >( existing.id );
    400                         if ( newentry && oldentry ) {
    401                                 if ( newentry->get_statements() && oldentry->get_statements() ) {
     416                        if ( isDefinition( added ) && isDefinition( existing.id ) ) {
     417                                if ( isFunction( added ) ) {
    402418                                        return handleConflicts( existing, "duplicate function definition for " );
    403                                 } // if
    404                         } else {
    405                                 // two objects with the same mangled name defined in the same scope.
    406                                 // both objects must be marked extern or both must be intrinsic for this to be okay
    407                                 // xxx - perhaps it's actually if either is intrinsic then this is okay?
    408                                 //       might also need to be same storage class?
    409                                 ObjectDecl * newobj = dynamic_cast< ObjectDecl * >( added );
    410                                 ObjectDecl * oldobj = dynamic_cast< ObjectDecl * >( existing.id );
    411                                 if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) {
     419                                } else {
    412420                                        return handleConflicts( existing, "duplicate object definition for " );
    413421                                } // if
  • src/SymTab/Mangler.cc

    r4a333d35 rcac8a6e  
    3535                namespace {
    3636                        /// Mangles names to a unique C identifier
    37                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> {
     37                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
    3838                                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
    3939                                Mangler( const Mangler & ) = delete;
     
    5555                                void postvisit( EnumInstType * aggregateUseType );
    5656                                void postvisit( TypeInstType * aggregateUseType );
     57                                void postvisit( TraitInstType * inst );
    5758                                void postvisit( TupleType * tupleType );
    5859                                void postvisit( VarArgsType * varArgsType );
     
    7071                                bool typeMode;                  ///< Produce a unique mangled name for a type
    7172                                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
     73                                bool inFunctionType = false;    ///< Include type qualifiers if false.
    7274
    7375                                void mangleDecl( DeclarationWithType *declaration );
     
    177179                        void Mangler::postvisit( PointerType * pointerType ) {
    178180                                printQualifiers( pointerType );
    179                                 mangleName << "P";
     181                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
     182                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << "P";
    180183                                maybeAccept( pointerType->base, *visitor );
    181184                        }
     
    189192
    190193                        void Mangler::postvisit( ReferenceType * refType ) {
     194                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
     195                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
     196                                // by pretending every reference type is a function parameter.
     197                                GuardValue( inFunctionType );
     198                                inFunctionType = true;
    191199                                printQualifiers( refType );
    192                                 mangleName << "R";
    193200                                maybeAccept( refType->base, *visitor );
    194201                        }
     
    206213                                printQualifiers( functionType );
    207214                                mangleName << "F";
     215                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
     216                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
     217                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
     218                                GuardValue( inFunctionType );
     219                                inFunctionType = true;
    208220                                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
    209221                                acceptAll( returnTypes, *visitor );
     
    270282                        }
    271283
     284                        void Mangler::postvisit( TraitInstType * inst ) {
     285                                printQualifiers( inst );
     286                                mangleName << "_Y" << inst->name << "_";
     287                        }
     288
    272289                        void Mangler::postvisit( TupleType * tupleType ) {
    273290                                printQualifiers( tupleType );
     
    304321                                // skip if not including qualifiers
    305322                                if ( typeMode ) return;
    306 
    307323                                if ( ! type->get_forall().empty() ) {
    308324                                        std::list< std::string > assertionNames;
     
    337353                                        mangleName << "_";
    338354                                } // if
    339                                 if ( type->get_const() ) {
    340                                         mangleName << "C";
    341                                 } // if
    342                                 if ( type->get_volatile() ) {
    343                                         mangleName << "V";
    344                                 } // if
     355                                if ( ! inFunctionType ) {
     356                                        // these qualifiers do not distinguish the outermost type of a function parameter
     357                                        if ( type->get_const() ) {
     358                                                mangleName << "C";
     359                                        } // if
     360                                        if ( type->get_volatile() ) {
     361                                                mangleName << "V";
     362                                        } // if
     363                                        // Removed due to restrict not affecting function compatibility in GCC
     364                                        // if ( type->get_isRestrict() ) {
     365                                        //      mangleName << "E";
     366                                        // } // if
     367                                        if ( type->get_atomic() ) {
     368                                                mangleName << "A";
     369                                        } // if
     370                                }
    345371                                if ( type->get_mutex() ) {
    346372                                        mangleName << "M";
    347373                                } // if
    348                                 // Removed due to restrict not affecting function compatibility in GCC
    349                 //              if ( type->get_isRestrict() ) {
    350                 //                      mangleName << "E";
    351                 //              } // if
    352374                                if ( type->get_lvalue() ) {
    353375                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
    354376                                        mangleName << "L";
    355377                                }
    356                                 if ( type->get_atomic() ) {
    357                                         mangleName << "A";
    358                                 } // if
     378
     379                                if ( inFunctionType ) {
     380                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
     381                                        GuardValue( inFunctionType );
     382                                        inFunctionType = false;
     383                                }
    359384                        }
    360385                }       // namespace
  • src/SynTree/ApplicationExpr.cc

    r4a333d35 rcac8a6e  
    4949}
    5050
     51ParamEntry::ParamEntry( ParamEntry && other ) :
     52                decl( other.decl ), actualType( other.actualType ), formalType( other.formalType ), expr( other.expr ), inferParams( std::move( other.inferParams ) ) {
     53        other.actualType = nullptr;
     54        other.formalType = nullptr;
     55        other.expr = nullptr;
     56}
     57
     58ParamEntry & ParamEntry::operator=( ParamEntry && other ) {
     59        if ( &other == this ) return *this;
     60        delete actualType;
     61        delete formalType;
     62        delete expr;
     63        decl = other.decl;
     64        actualType = other.actualType;
     65        formalType = other.formalType;
     66        expr = other.expr;
     67        other.actualType = nullptr;
     68        other.formalType = nullptr;
     69        other.expr = nullptr;
     70        inferParams = std::move( other.inferParams );
     71        return *this;
     72}
     73
    5174ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
    5275        PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );
  • src/SynTree/Expression.cc

    r4a333d35 rcac8a6e  
    5050}
    5151
     52void Expression::spliceInferParams( Expression * other ) {
     53        if ( ! other ) return;
     54        for ( auto p : other->inferParams ) {
     55                inferParams[p.first] = std::move( p.second );
     56        }
     57}
     58
    5259Expression::~Expression() {
    5360        delete env;
  • src/SynTree/Expression.h

    r4a333d35 rcac8a6e  
    4141        ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
    4242        ParamEntry( const ParamEntry & other );
     43        ParamEntry( ParamEntry && other );
    4344        ~ParamEntry();
    4445        ParamEntry & operator=( const ParamEntry & other );
     46        ParamEntry & operator=( ParamEntry && other );
    4547
    4648        UniqueId decl;
     
    7375
    7476        InferredParams & get_inferParams() { return inferParams; }
     77
     78        // move other's inferParams to this
     79        void spliceInferParams( Expression * other );
    7580
    7681        virtual Expression * clone() const override = 0;
  • src/Tuples/TupleAssignment.cc

    r4a333d35 rcac8a6e  
    154154                                                lhsAlt.expr = new CastExpr( lhsAlt.expr,
    155155                                                                new ReferenceType( Type::Qualifiers(),
    156                                                                         lhsAlt.expr->get_result()->clone() ) );
     156                                                                        lhsAlt.expr->result->clone() ) );
    157157                                        }
    158158
     
    298298        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
    299299                assert( expr->result && ! expr->get_result()->isVoid() );
    300                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
     300                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->result->clone(), new SingleInit( expr->clone() ) );
    301301                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
    302                 if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
     302                if ( ! dynamic_cast< ReferenceType * >( expr->result ) ) {
    303303                        ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
    304304                        ret->init = ctorInit;
     
    318318                assert( (! lhs.empty() && rhs.size() <= 1) || (lhs.empty() && rhs.empty()) );
    319319
     320                // xxx - may need to split this up into multiple declarations, because potential conversion to references
     321                //  probably should not reference local variable - see MultipleAssignMatcher::match
    320322                ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
    321323                for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
     
    336338                        std::list< ObjectDecl * > ltmp;
    337339                        std::list< ObjectDecl * > rtmp;
    338                         std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), [&]( ResolvExpr::Alternative & alt ){
    339                                 return newObject( lhsNamer, alt.expr );
    340                         });
    341                         std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), [&]( ResolvExpr::Alternative & alt ){
    342                                 return newObject( rhsNamer, alt.expr );
    343                         });
    344                         zipWith( ltmp.begin(), ltmp.end(), rtmp.begin(), rtmp.end(), back_inserter(out), [&](ObjectDecl * obj1, ObjectDecl * obj2 ) { return createFunc(spotter.fname, obj1, obj2); } );
     340                        for ( auto p : group_iterate( lhs, rhs ) ) {
     341                                ResolvExpr::Alternative & lhsAlt = std::get<0>(p);
     342                                ResolvExpr::Alternative & rhsAlt = std::get<1>(p);
     343                                // convert RHS to LHS type minus one reference -- important for the case where LHS is && and RHS is lvalue, etc.
     344                                ReferenceType * lhsType = strict_dynamic_cast<ReferenceType *>( lhsAlt.expr->result );
     345                                rhsAlt.expr = new CastExpr( rhsAlt.expr, lhsType->base->clone() );
     346                                ObjectDecl * lobj = newObject( lhsNamer, lhsAlt.expr );
     347                                ObjectDecl * robj = newObject( rhsNamer, rhsAlt.expr );
     348                                out.push_back( createFunc(spotter.fname, lobj, robj) );
     349                                ltmp.push_back( lobj );
     350                                rtmp.push_back( robj );
     351                        }
    345352                        tmpDecls.splice( tmpDecls.end(), ltmp );
    346353                        tmpDecls.splice( tmpDecls.end(), rtmp );
  • src/Tuples/TupleExpansion.cc

    r4a333d35 rcac8a6e  
    3030#include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
    3131#include "SynTree/Visitor.h"      // for Visitor
     32#include "Tuples.h"
    3233
    3334class CompoundStmt;
     
    128129                        Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
    129130                        // aggregate expressions which might be impure must be wrapped in unique expressions
    130                         // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
    131                         // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
    132                         aggr = new UniqueExpr( aggr );
     131                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
    133132                        for ( Expression *& expr : tupleExpr->exprs ) {
    134133                                expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
     
    227226
    228227        Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
    229                 Expression * tuple = tupleExpr->get_tuple();
     228                Expression * tuple = tupleExpr->tuple;
    230229                assert( tuple );
    231                 tupleExpr->set_tuple( nullptr );
    232                 unsigned int idx = tupleExpr->get_index();
    233                 TypeSubstitution * env = tupleExpr->get_env();
    234                 tupleExpr->set_env( nullptr );
     230                tupleExpr->tuple = nullptr;
     231                unsigned int idx = tupleExpr->index;
     232                TypeSubstitution * env = tupleExpr->env;
     233                tupleExpr->env = nullptr;
    235234                delete tupleExpr;
    236235
    237                 StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
    238                 StructDecl * structDecl = type->get_baseStruct();
    239                 assert( structDecl->get_members().size() > idx );
    240                 Declaration * member = *std::next(structDecl->get_members().begin(), idx);
     236                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( tuple ) ) {
     237                        if ( ! maybeImpureIgnoreUnique( tupleExpr ) ) {
     238                                // optimization: definitely pure tuple expr => can reduce to the only relevant component.
     239                                assert( tupleExpr->exprs.size() > idx );
     240                                Expression *& expr = *std::next(tupleExpr->exprs.begin(), idx);
     241                                Expression * ret = expr;
     242                                ret->env = env;
     243                                expr = nullptr; // remove from list so it can safely be deleted
     244                                delete tupleExpr;
     245                                return ret;
     246                        }
     247                }
     248
     249                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->result );
     250                StructDecl * structDecl = type->baseStruct;
     251                assert( structDecl->members.size() > idx );
     252                Declaration * member = *std::next(structDecl->members.begin(), idx);
    241253                MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
    242                 memExpr->set_env( env );
     254                memExpr->env = env;
    243255                return memExpr;
    244256        }
  • src/benchmark/Makefile.am

    r4a333d35 rcac8a6e  
    265265
    266266compile-array$(EXEEXT):
    267         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     267        @${CC} -quiet -fsyntax-only -w ../tests/array.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    268268
    269269compile-attributes$(EXEEXT):
    270         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     270        @${CC} -quiet -fsyntax-only -w ../tests/attributes.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    271271
    272272compile-empty$(EXEEXT):
    273         @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     273        @${CC} -quiet -fsyntax-only -w compile/empty.c                          @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    274274
    275275compile-expression$(EXEEXT):
    276         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     276        @${CC} -quiet -fsyntax-only -w ../tests/expression.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    277277
    278278compile-io$(EXEEXT):
    279         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     279        @${CC} -quiet -fsyntax-only -w ../tests/io.c                                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    280280
    281281compile-monitor$(EXEEXT):
    282         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/monitor.c           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     282        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    283283
    284284compile-operators$(EXEEXT):
    285         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     285        @${CC} -quiet -fsyntax-only -w ../tests/operators.c                     @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    286286
    287287compile-thread$(EXEEXT):
    288         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/thread.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     288        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/thread.c             @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    289289
    290290compile-typeof$(EXEEXT):
    291         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c                               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    292 
     291        @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     292
  • src/benchmark/Makefile.in

    r4a333d35 rcac8a6e  
    670670
    671671compile-array$(EXEEXT):
    672         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     672        @${CC} -quiet -fsyntax-only -w ../tests/array.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    673673
    674674compile-attributes$(EXEEXT):
    675         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     675        @${CC} -quiet -fsyntax-only -w ../tests/attributes.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    676676
    677677compile-empty$(EXEEXT):
    678         @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     678        @${CC} -quiet -fsyntax-only -w compile/empty.c                          @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    679679
    680680compile-expression$(EXEEXT):
    681         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     681        @${CC} -quiet -fsyntax-only -w ../tests/expression.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    682682
    683683compile-io$(EXEEXT):
    684         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     684        @${CC} -quiet -fsyntax-only -w ../tests/io.c                                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    685685
    686686compile-monitor$(EXEEXT):
    687         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/monitor.c           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     687        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    688688
    689689compile-operators$(EXEEXT):
    690         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     690        @${CC} -quiet -fsyntax-only -w ../tests/operators.c                     @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    691691
    692692compile-thread$(EXEEXT):
    693         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/thread.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     693        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/thread.c             @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    694694
    695695compile-typeof$(EXEEXT):
    696         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c                               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     696        @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    697697
    698698# Tell versions [3.59,3.63) of GNU make to not export all variables.
  • src/main.cc

    r4a333d35 rcac8a6e  
    300300
    301301                PASS( "expandUniqueExpr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
    302                 Tuples::expandUniqueExpr( translationUnit );
    303302
    304303                PASS( "translateEHM" , ControlStruct::translateEHM( translationUnit ) );
  • src/tests/.expect/KRfunctions.x64.txt

    r4a333d35 rcac8a6e  
    1111    signed int __i__i_1;
    1212};
    13 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
    14 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
    15 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
    16 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
    17 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1);
    18 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
    19     ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
     13static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     14static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     15static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     16static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     17static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
     18static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     19    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
    2020}
    21 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
    22     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
     21static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     22    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
    2323}
    24 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
    25     ((void)((*___dst__R2sS_1).__i__i_1) /* ^?{} */);
     24static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     25    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
    2626}
    27 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     27static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
    2828    struct S ___ret__2sS_1;
    29     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
    30     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
     29    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     30    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
    3131    return ___ret__2sS_1;
    3232}
    33 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
    34     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
     33static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
     34    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    3535}
    3636signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     
    4444    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    4545}
    46 signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
    47     __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
     46signed int (*__f6__FFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     47    __attribute__ ((unused)) signed int (*___retval_f6__Fi_i__1)(signed int __anonymous_object1);
    4848}
    49 signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
    50     __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
     49signed int (*__f7__FFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     50    __attribute__ ((unused)) signed int (*___retval_f7__Fi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5151}
    5252signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
    5353    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5454}
    55 signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     55signed int *const __f9__FPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
    5656    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    5757}
    58 signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
    59     __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     58signed int *(*__f10__FFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     59    __attribute__ ((unused)) signed int *(*___retval_f10__FPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
    6060    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    61     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
    62     return ___retval_f10__PFPi_ii__1;
     61    ((void)(___retval_f10__FPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     62    return ___retval_f10__FPi_ii__1;
    6363}
    6464signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     
    7777    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    7878}
    79 const signed int __fred__FCi___1(){
     79const signed int __fred__Fi___1(){
    8080    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
    81     signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     81    signed int *(*__x__FPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
    8282    signed int __a__i_2;
    8383    signed int __b__i_2;
    8484    signed int *(*_tmp_cp_ret2)(signed int __x__i_1, signed int __y__i_1);
    85     ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
     85    ((void)(__x__FPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
    8686    ((void)(_tmp_cp_ret2) /* ^?{} */);
    87     const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     87    const signed int __f1__Fi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
    8888        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    8989    }
    90     const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     90    const signed int __f2__Fi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
    9191        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9292    }
  • src/tests/.expect/KRfunctions.x86.txt

    r4a333d35 rcac8a6e  
    1111    signed int __i__i_1;
    1212};
    13 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
    14 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
    15 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
    16 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
    17 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1);
    18 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
    19     ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
     13static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     14static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     15static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
     16static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
     17static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
     18static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     19    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
    2020}
    21 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
    22     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
     21static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     22    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
    2323}
    24 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
    25     ((void)((*___dst__R2sS_1).__i__i_1) /* ^?{} */);
     24static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
     25    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
    2626}
    27 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     27static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
    2828    struct S ___ret__2sS_1;
    29     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
    30     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
     29    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     30    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
    3131    return ___ret__2sS_1;
    3232}
    33 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
    34     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
     33static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
     34    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
    3535}
    3636signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
     
    4444    __attribute__ ((unused)) signed int ___retval_f5__i_1;
    4545}
    46 signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
    47     __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
     46signed int (*__f6__FFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     47    __attribute__ ((unused)) signed int (*___retval_f6__Fi_i__1)(signed int __anonymous_object1);
    4848}
    49 signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
    50     __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
     49signed int (*__f7__FFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     50    __attribute__ ((unused)) signed int (*___retval_f7__Fi_ii__1)(signed int __a__i_1, signed int __b__i_1);
    5151}
    5252signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
    5353    __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
    5454}
    55 signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     55signed int *const __f9__FPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
    5656    __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
    5757}
    58 signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
    59     __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
     58signed int *(*__f10__FFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     59    __attribute__ ((unused)) signed int *(*___retval_f10__FPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
    6060    signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
    61     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
    62     return ___retval_f10__PFPi_ii__1;
     61    ((void)(___retval_f10__FPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     62    return ___retval_f10__FPi_ii__1;
    6363}
    6464signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
     
    7777    __attribute__ ((unused)) signed int ___retval_f15__i_1;
    7878}
    79 const signed int __fred__FCi___1(){
     79const signed int __fred__Fi___1(){
    8080    __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
    81     signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     81    signed int *(*__x__FPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
    8282    signed int __a__i_2;
    8383    signed int __b__i_2;
    8484    signed int *(*_tmp_cp_ret2)(signed int __x__i_1, signed int __y__i_1);
    85     ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
     85    ((void)(__x__FPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
    8686    ((void)(_tmp_cp_ret2) /* ^?{} */);
    87     const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
     87    const signed int __f1__Fi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
    8888        __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
    8989    }
    90     const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
     90    const signed int __f2__Fi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
    9191        __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
    9292    }
  • src/tests/.expect/attributes.x64.txt

    r4a333d35 rcac8a6e  
    55struct __attribute__ ((unused)) __anonymous0 {
    66};
    7 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    8 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
    9 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    10 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
    11 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
    12 }
    13 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
    14 }
    15 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
    16 }
    17 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     7static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     8static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     9static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     10static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     11static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     12}
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     14}
     15static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     16}
     17static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
    1818    struct __anonymous0 ___ret__13s__anonymous0_1;
    19     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
     19    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
    2020    return ___ret__13s__anonymous0_1;
    2121}
     
    2323struct __attribute__ ((unused)) Agn2 {
    2424};
    25 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
    26 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
    27 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
    28 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
    29 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
    30 }
    31 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
    32 }
    33 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
    34 }
    35 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     25static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     26static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     27static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     28static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     29static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     30}
     31static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     32}
     33static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     34}
     35static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
    3636    struct Agn2 ___ret__5sAgn2_1;
    37     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
     37    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
    3838    return ___ret__5sAgn2_1;
    3939}
     
    5959    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
    6060};
    61 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
    62 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
    63 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
    64 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
    65 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
    66 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
    67 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
    68 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
    69 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
    70 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
    71 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
    72 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
    73 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
    74 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
    75 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
    76     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */);
    77     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
    78     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
    79     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    80     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    81     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    82     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    83     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    84     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    85     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    86 }
    87 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){
    88     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
    89     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
    90     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
    91     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
    92     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
    93     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
    94     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
    95     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
    96     ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
    97     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
    98 }
    99 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
    100     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */);
    101     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ^?{} */);
    102     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */);
    103     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */);
    104     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ^?{} */);
    105     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ^?{} */);
    106     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ^?{} */);
    107     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ^?{} */);
    108     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ^?{} */);
    109     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ^?{} */);
    110 }
    111 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){
     61static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     62static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     63static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     64static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     65static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
     66static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
     67static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
     68static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
     69static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
     70static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
     71static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
     72static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
     73static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
     74static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
     75static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     76    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
     77    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     78    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     79    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     80    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     81    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     82    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     83    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     84    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     85    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     86}
     87static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     88    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     89    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     90    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     91    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     92    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     93    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     94    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     95    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     96    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     97    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
     98}
     99static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     100    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
     101    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ^?{} */);
     102    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
     103    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
     104    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
     105    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
     106    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
     107    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
     108    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
     109    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
     110}
     111static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
    112112    struct Fdl ___ret__4sFdl_1;
    113     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
    114     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
    115     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
    116     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
    117     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
    118     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
    119     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
    120     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
    121     ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
    122     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
    123     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__R4sFdl_1)));
     113    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     114    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     115    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     116    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     117    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     118    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     119    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     120    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     121    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     122    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     123    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
    124124    return ___ret__4sFdl_1;
    125125}
    126 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
    127     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    128     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
    129     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
    130     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    131     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    132     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    133     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    134     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    135     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    136     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    137 }
    138 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
    139     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    140     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    141     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
    142     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    143     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    144     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    145     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    146     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    147     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    148     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    149 }
    150 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
    151     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    152     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    153     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    154     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    155     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    156     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    157     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    158     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    159     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    160     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    161 }
    162 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
    163     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    164     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    165     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    166     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    167     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    168     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    169     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    170     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    171     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    172     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    173 }
    174 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
    175     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    176     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    177     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    178     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    179     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    180     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    181     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    182     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    183     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    184     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    185 }
    186 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
    187     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    188     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    189     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    190     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    191     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    192     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    193     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    194     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    195     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    196     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    197 }
    198 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
    199     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    200     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    201     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    202     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    203     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    204     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    205     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    206     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    207     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    208     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    209 }
    210 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
    211     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    212     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    213     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    214     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    215     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    216     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    217     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    218     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
    219     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    220     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    221 }
    222 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
    223     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    224     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    225     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    226     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    227     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    228     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    229     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    230     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
    231     ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
    232     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    233 }
    234 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
    235     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    236     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    237     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    238     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    239     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    240     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    241     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    242     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
    243     ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
    244     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
     126static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     127    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     128    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     129    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     130    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     131    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     132    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     133    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     134    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     135    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     136    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     137}
     138static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
     139    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     140    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     141    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     142    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     143    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     144    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     145    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     146    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     147    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     148    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     149}
     150static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
     151    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     152    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     153    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     154    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     155    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     156    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     157    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     158    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     159    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     160    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     161}
     162static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
     163    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     164    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     165    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     166    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     167    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     168    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     169    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     170    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     171    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     172    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     173}
     174static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
     175    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     176    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     177    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     178    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     179    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     180    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     181    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     182    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     183    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     184    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     185}
     186static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
     187    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     188    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     189    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     190    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     191    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     192    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     193    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     194    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     195    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     196    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     197}
     198static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
     199    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     200    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     201    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     202    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     203    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     204    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     205    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     206    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     207    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     208    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     209}
     210static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
     211    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     212    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     213    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     214    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     215    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     216    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     217    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     218    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     219    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     220    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     221}
     222static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
     223    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     224    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     225    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     226    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     227    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     228    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     229    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     230    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     231    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
     232    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     233}
     234static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
     235    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     236    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     237    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     238    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     239    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     240    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     241    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     242    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     243    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     244    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
    245245}
    246246__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     
    251251__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned long int )5)];
    252252__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned long int )5)];
    253 __attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
    254 __attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
     253__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
     254__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
    255255__attribute__ ((unused,used)) signed int __f1__Fi___1();
    256256__attribute__ ((unused)) signed int __f1__Fi___1(){
    257257    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    258258}
    259 __attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
    260 __attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
     259__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
     260__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
    261261    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
    262262}
     
    265265    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
    266266}
    267 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object6);
    268 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object7){
    269     __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object8);
     267__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object6);
     268__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object7){
     269    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object8);
    270270}
    271271signed int __vtr__Fi___1(){
     
    290290    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
    291291}
    292 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
    293 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
     292signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
     293signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
    294294    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
    295295}
     
    297297signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
    298298signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
    299 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned long int )5)]));
    300 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
    301 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
    302 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
     299signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned long int )5)]));
     300signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     301signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     302signed int __tpr7__Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
    303303signed int __ad__Fi___1(){
    304304    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     
    317317        signed int __i__i_2;
    318318    };
    319     inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
    320         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ?{} */);
    321     }
    322     inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
    323         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
    324     }
    325     inline void ___destructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
    326         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ^?{} */);
    327     }
    328     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
     319    inline void ___constructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
     320        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ?{} */);
     321    }
     322    inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
     323        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
     324    }
     325    inline void ___destructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
     326        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ^?{} */);
     327    }
     328    inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
    329329        struct __anonymous4 ___ret__13s__anonymous4_2;
    330         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
    331         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__R13s__anonymous4_2)));
     330        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
     331        ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__13s__anonymous4_2)));
    332332        return ___ret__13s__anonymous4_2;
    333333    }
    334     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
    335         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
     334    inline void ___constructor__F_13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, signed int __i__i_2){
     335        ((void)((*___dst__13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
    336336    }
    337337    ((void)sizeof(struct __anonymous4 ));
     
    339339        __R__C13e__anonymous5_2,
    340340    };
    341     inline void ___constructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
    342     }
    343     inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
    344         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
    345     }
    346     inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
    347     }
    348     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
     341    inline void ___constructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
     342    }
     343    inline void ___constructor__F_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
     344        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
     345    }
     346    inline void ___destructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
     347    }
     348    inline enum __anonymous5 ___operator_assign__F13e__anonymous5_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
    349349        enum __anonymous5 ___ret__13e__anonymous5_2;
    350         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
    351         ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
     350        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2));
     351        ((void)(___ret__13e__anonymous5_2=(*___dst__13e__anonymous5_2)) /* ?{} */);
    352352        return ___ret__13e__anonymous5_2;
    353353    }
     
    357357signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
    358358signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
    359 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
    360 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
    361 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
    362 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
     359signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
     360signed int __apd5__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
     361signed int __apd6__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
     362signed int __apd7__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
    363363struct Vad {
    364364    __attribute__ ((unused)) signed int __anonymous_object32;
     
    367367    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
    368368};
    369 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
    370 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
    371 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
    372 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
    373 static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
    374 static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
    375 static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned long int )10)]);
    376 static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
    377 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
    378     ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ?{} */);
    379     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
     369static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     370static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     371static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     372static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     373static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
     374static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
     375static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned long int )10)]);
     376static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
     377static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     378    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ?{} */);
     379    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
    380380    {
    381381        signed int _index0 = 0;
    382382        for (;(_index0<10);((void)(++_index0))) {
    383             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index0)]) /* ?{} */);
    384         }
    385 
    386     }
    387 
    388     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    389 }
    390 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
    391     ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
    392     ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
     383            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index0)]) /* ?{} */);
     384        }
     385
     386    }
     387
     388    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     389}
     390static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     391    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
     392    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
    393393    {
    394394        signed int _index1 = 0;
    395395        for (;(_index1<10);((void)(++_index1))) {
    396             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index1)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
    397         }
    398 
    399     }
    400 
    401     ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
    402 }
    403 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
    404     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ^?{} */);
     396            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index1)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
     397        }
     398
     399    }
     400
     401    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
     402}
     403static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     404    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ^?{} */);
    405405    {
    406406        signed int _index2 = (10-1);
    407407        for (;(_index2>=0);((void)(--_index2))) {
    408             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index2)]) /* ^?{} */);
    409         }
    410 
    411     }
    412 
    413     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ^?{} */);
    414     ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ^?{} */);
    415 }
    416 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
     408            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index2)]) /* ^?{} */);
     409        }
     410
     411    }
     412
     413    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ^?{} */);
     414    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ^?{} */);
     415}
     416static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
    417417    struct Vad ___ret__4sVad_1;
    418     ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
    419     ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
     418    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
     419    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
    420420    {
    421421        signed int _index3 = 0;
    422422        for (;(_index3<10);((void)(++_index3))) {
    423             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index3)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index3)]));
    424         }
    425 
    426     }
    427 
    428     ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
    429     ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__R4sVad_1)));
     423            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index3)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index3)]));
     424        }
     425
     426    }
     427
     428    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
     429    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
    430430    return ___ret__4sVad_1;
    431431}
    432 static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
    433     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
    434     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
     432static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
     433    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
     434    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
    435435    {
    436436        signed int _index4 = 0;
    437437        for (;(_index4<10);((void)(++_index4))) {
    438             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index4)]) /* ?{} */);
    439         }
    440 
    441     }
    442 
    443     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    444 }
    445 static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
    446     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
    447     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
     438            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index4)]) /* ?{} */);
     439        }
     440
     441    }
     442
     443    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     444}
     445static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
     446    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
     447    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
    448448    {
    449449        signed int _index5 = 0;
    450450        for (;(_index5<10);((void)(++_index5))) {
    451             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index5)]) /* ?{} */);
    452         }
    453 
    454     }
    455 
    456     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    457 }
    458 static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned long int )10)]){
    459     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
    460     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
     451            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index5)]) /* ?{} */);
     452        }
     453
     454    }
     455
     456    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     457}
     458static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned long int )10)]){
     459    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
     460    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
    461461    {
    462462        signed int _index6 = 0;
    463463        for (;(_index6<10);((void)(++_index6))) {
    464             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index6)]=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
    465         }
    466 
    467     }
    468 
    469     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    470 }
    471 static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
    472     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
    473     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
     464            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index6)]=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
     465        }
     466
     467    }
     468
     469    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     470}
     471static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
     472    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
     473    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
    474474    {
    475475        signed int _index7 = 0;
    476476        for (;(_index7<10);((void)(++_index7))) {
    477             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index7)]=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
    478         }
    479 
    480     }
    481 
    482     ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
    483 }
     477            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index7)]=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
     478        }
     479
     480    }
     481
     482    ((void)((*___dst__4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
     483}
  • src/tests/.expect/attributes.x86.txt

    r4a333d35 rcac8a6e  
    55struct __attribute__ ((unused)) __anonymous0 {
    66};
    7 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    8 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
    9 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    10 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
    11 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
    12 }
    13 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
    14 }
    15 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
    16 }
    17 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     7static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     8static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     9static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     10static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     11static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     12}
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     14}
     15static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     16}
     17static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
    1818    struct __anonymous0 ___ret__13s__anonymous0_1;
    19     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
     19    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
    2020    return ___ret__13s__anonymous0_1;
    2121}
     
    2323struct __attribute__ ((unused)) Agn2 {
    2424};
    25 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
    26 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
    27 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
    28 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
    29 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
    30 }
    31 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
    32 }
    33 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
    34 }
    35 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     25static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     26static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     27static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
     28static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
     29static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     30}
     31static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     32}
     33static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
     34}
     35static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
    3636    struct Agn2 ___ret__5sAgn2_1;
    37     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
     37    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
    3838    return ___ret__5sAgn2_1;
    3939}
     
    5959    __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
    6060};
    61 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
    62 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
    63 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
    64 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
    65 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
    66 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
    67 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
    68 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
    69 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
    70 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
    71 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
    72 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
    73 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
    74 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
    75 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
    76     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */);
    77     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
    78     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
    79     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    80     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    81     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    82     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    83     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    84     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    85     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    86 }
    87 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){
    88     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
    89     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
    90     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
    91     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
    92     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
    93     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
    94     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
    95     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
    96     ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
    97     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
    98 }
    99 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
    100     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */);
    101     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ^?{} */);
    102     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */);
    103     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */);
    104     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ^?{} */);
    105     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ^?{} */);
    106     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ^?{} */);
    107     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ^?{} */);
    108     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ^?{} */);
    109     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ^?{} */);
    110 }
    111 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){
     61static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     62static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     63static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
     64static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
     65static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
     66static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
     67static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
     68static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
     69static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
     70static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
     71static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
     72static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
     73static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
     74static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
     75static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     76    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
     77    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     78    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     79    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     80    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     81    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     82    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     83    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     84    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     85    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     86}
     87static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     88    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     89    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     90    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     91    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     92    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     93    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     94    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     95    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     96    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     97    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
     98}
     99static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
     100    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
     101    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ^?{} */);
     102    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
     103    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
     104    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
     105    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
     106    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
     107    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
     108    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
     109    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
     110}
     111static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
    112112    struct Fdl ___ret__4sFdl_1;
    113     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
    114     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
    115     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
    116     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
    117     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
    118     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
    119     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
    120     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
    121     ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
    122     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
    123     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__R4sFdl_1)));
     113    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     114    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     115    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     116    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     117    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     118    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     119    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     120    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     121    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     122    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     123    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
    124124    return ___ret__4sFdl_1;
    125125}
    126 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
    127     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    128     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
    129     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
    130     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    131     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    132     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    133     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    134     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    135     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    136     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    137 }
    138 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
    139     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    140     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    141     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
    142     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    143     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    144     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    145     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    146     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    147     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    148     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    149 }
    150 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
    151     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    152     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    153     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    154     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
    155     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    156     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    157     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    158     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    159     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    160     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    161 }
    162 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
    163     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    164     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    165     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    166     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    167     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
    168     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    169     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    170     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    171     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    172     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    173 }
    174 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
    175     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    176     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    177     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    178     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    179     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    180     ((void)((*___dst__R4sFdl_1).__f6__i_1) /* ?{} */);
    181     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    182     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    183     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    184     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    185 }
    186 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
    187     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    188     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    189     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    190     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    191     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    192     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    193     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
    194     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    195     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    196     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    197 }
    198 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
    199     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    200     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    201     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    202     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    203     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    204     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    205     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    206     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
    207     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    208     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    209 }
    210 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
    211     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    212     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    213     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    214     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    215     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    216     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    217     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    218     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
    219     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
    220     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    221 }
    222 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
    223     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    224     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    225     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    226     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    227     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    228     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    229     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    230     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
    231     ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
    232     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
    233 }
    234 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
    235     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
    236     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
    237     ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
    238     ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
    239     ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
    240     ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
    241     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
    242     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
    243     ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
    244     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
     126static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     127    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     128    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
     129    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     130    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     131    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     132    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     133    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     134    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     135    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     136    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     137}
     138static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
     139    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     140    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     141    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
     142    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     143    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     144    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     145    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     146    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     147    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     148    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     149}
     150static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
     151    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     152    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     153    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     154    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
     155    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     156    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     157    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     158    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     159    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     160    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     161}
     162static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
     163    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     164    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     165    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     166    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     167    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
     168    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     169    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     170    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     171    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     172    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     173}
     174static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
     175    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     176    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     177    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     178    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     179    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     180    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
     181    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     182    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     183    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     184    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     185}
     186static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
     187    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     188    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     189    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     190    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     191    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     192    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     193    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
     194    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     195    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     196    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     197}
     198static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
     199    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     200    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     201    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     202    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     203    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     204    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     205    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     206    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
     207    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     208    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     209}
     210static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
     211    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     212    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     213    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     214    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     215    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     216    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     217    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     218    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     219    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
     220    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     221}
     222static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
     223    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     224    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     225    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     226    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     227    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     228    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     229    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     230    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     231    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
     232    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
     233}
     234static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
     235    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     236    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
     237    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
     238    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
     239    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
     240    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
     241    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     242    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
     243    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     244    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
    245245}
    246246__attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
     
    251251__attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
    252252__attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
    253 __attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
    254 __attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
     253__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
     254__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
    255255__attribute__ ((unused,used)) signed int __f1__Fi___1();
    256256__attribute__ ((unused)) signed int __f1__Fi___1(){
    257257    __attribute__ ((unused)) signed int ___retval_f1__i_1;
    258258}
    259 __attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
    260 __attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
     259__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
     260__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
    261261    __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
    262262}
     
    265265    __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
    266266}
    267 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object6);
    268 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object7){
    269     __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object8);
     267__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object6);
     268__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object7){
     269    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object8);
    270270}
    271271signed int __vtr__Fi___1(){
     
    290290    __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
    291291}
    292 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
    293 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
     292signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
     293signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
    294294    __attribute__ ((unused)) signed int ___retval_ipd4__i_1;
    295295}
     
    297297signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
    298298signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
    299 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
    300 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
    301 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
    302 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
     299signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
     300signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     301signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
     302signed int __tpr7__Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
    303303signed int __ad__Fi___1(){
    304304    __attribute__ ((unused)) signed int ___retval_ad__i_1;
     
    317317        signed int __i__i_2;
    318318    };
    319     inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
    320         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ?{} */);
    321     }
    322     inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
    323         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
    324     }
    325     inline void ___destructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
    326         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ^?{} */);
    327     }
    328     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
     319    inline void ___constructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
     320        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ?{} */);
     321    }
     322    inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
     323        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
     324    }
     325    inline void ___destructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
     326        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ^?{} */);
     327    }
     328    inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
    329329        struct __anonymous4 ___ret__13s__anonymous4_2;
    330         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
    331         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__R13s__anonymous4_2)));
     330        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
     331        ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__13s__anonymous4_2)));
    332332        return ___ret__13s__anonymous4_2;
    333333    }
    334     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
    335         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
     334    inline void ___constructor__F_13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, signed int __i__i_2){
     335        ((void)((*___dst__13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
    336336    }
    337337    ((void)sizeof(struct __anonymous4 ));
     
    339339        __R__C13e__anonymous5_2,
    340340    };
    341     inline void ___constructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
    342     }
    343     inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
    344         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
    345     }
    346     inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
    347     }
    348     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
     341    inline void ___constructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
     342    }
     343    inline void ___constructor__F_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
     344        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
     345    }
     346    inline void ___destructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
     347    }
     348    inline enum __anonymous5 ___operator_assign__F13e__anonymous5_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
    349349        enum __anonymous5 ___ret__13e__anonymous5_2;
    350         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
    351         ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
     350        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2));
     351        ((void)(___ret__13e__anonymous5_2=(*___dst__13e__anonymous5_2)) /* ?{} */);
    352352        return ___ret__13e__anonymous5_2;
    353353    }
     
    357357signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
    358358signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
    359 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
    360 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
    361 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
    362 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
     359signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
     360signed int __apd5__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
     361signed int __apd6__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
     362signed int __apd7__Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
    363363struct Vad {
    364364    __attribute__ ((unused)) signed int __anonymous_object32;
     
    367367    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
    368368};
    369 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
    370 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
    371 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
    372 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
    373 static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
    374 static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
    375 static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned int )10)]);
    376 static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
    377 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
    378     ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ?{} */);
    379     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
     369static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     370static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     371static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
     372static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
     373static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
     374static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
     375static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned int )10)]);
     376static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
     377static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     378    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ?{} */);
     379    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
    380380    {
    381381        signed int _index0 = 0;
    382382        for (;(_index0<10);((void)(++_index0))) {
    383             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index0]) /* ?{} */);
    384         }
    385 
    386     }
    387 
    388     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    389 }
    390 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
    391     ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
    392     ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
     383            ((void)((*___dst__4sVad_1).__anonymous_object34[_index0]) /* ?{} */);
     384        }
     385
     386    }
     387
     388    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     389}
     390static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     391    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
     392    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
    393393    {
    394394        signed int _index1 = 0;
    395395        for (;(_index1<10);((void)(++_index1))) {
    396             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index1]=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
    397         }
    398 
    399     }
    400 
    401     ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
    402 }
    403 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
    404     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ^?{} */);
     396            ((void)((*___dst__4sVad_1).__anonymous_object34[_index1]=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
     397        }
     398
     399    }
     400
     401    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
     402}
     403static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
     404    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ^?{} */);
    405405    {
    406406        signed int _index2 = (10-1);
    407407        for (;(_index2>=0);((void)(--_index2))) {
    408             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index2]) /* ^?{} */);
    409         }
    410 
    411     }
    412 
    413     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ^?{} */);
    414     ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ^?{} */);
    415 }
    416 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
     408            ((void)((*___dst__4sVad_1).__anonymous_object34[_index2]) /* ^?{} */);
     409        }
     410
     411    }
     412
     413    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ^?{} */);
     414    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ^?{} */);
     415}
     416static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
    417417    struct Vad ___ret__4sVad_1;
    418     ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
    419     ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
     418    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
     419    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
    420420    {
    421421        signed int _index3 = 0;
    422422        for (;(_index3<10);((void)(++_index3))) {
    423             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
    424         }
    425 
    426     }
    427 
    428     ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
    429     ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__R4sVad_1)));
     423            ((void)((*___dst__4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
     424        }
     425
     426    }
     427
     428    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
     429    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
    430430    return ___ret__4sVad_1;
    431431}
    432 static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
    433     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
    434     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
     432static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
     433    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
     434    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
    435435    {
    436436        signed int _index4 = 0;
    437437        for (;(_index4<10);((void)(++_index4))) {
    438             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index4]) /* ?{} */);
    439         }
    440 
    441     }
    442 
    443     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    444 }
    445 static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
    446     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
    447     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
     438            ((void)((*___dst__4sVad_1).__anonymous_object34[_index4]) /* ?{} */);
     439        }
     440
     441    }
     442
     443    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     444}
     445static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
     446    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
     447    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
    448448    {
    449449        signed int _index5 = 0;
    450450        for (;(_index5<10);((void)(++_index5))) {
    451             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index5]) /* ?{} */);
    452         }
    453 
    454     }
    455 
    456     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    457 }
    458 static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned int )10)]){
    459     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
    460     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
     451            ((void)((*___dst__4sVad_1).__anonymous_object34[_index5]) /* ?{} */);
     452        }
     453
     454    }
     455
     456    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     457}
     458static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned int )10)]){
     459    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
     460    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
    461461    {
    462462        signed int _index6 = 0;
    463463        for (;(_index6<10);((void)(++_index6))) {
    464             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index6]=__anonymous_object51[_index6]) /* ?{} */);
    465         }
    466 
    467     }
    468 
    469     ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
    470 }
    471 static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
    472     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
    473     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
     464            ((void)((*___dst__4sVad_1).__anonymous_object34[_index6]=__anonymous_object51[_index6]) /* ?{} */);
     465        }
     466
     467    }
     468
     469    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
     470}
     471static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
     472    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
     473    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
    474474    {
    475475        signed int _index7 = 0;
    476476        for (;(_index7<10);((void)(++_index7))) {
    477             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
    478         }
    479 
    480     }
    481 
    482     ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
    483 }
     477            ((void)((*___dst__4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
     478        }
     479
     480    }
     481
     482    ((void)((*___dst__4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
     483}
  • src/tests/.expect/declarationSpecifier.x64.txt

    r4a333d35 rcac8a6e  
    1010    signed int __i__i_1;
    1111};
    12 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    13 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
    14 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    15 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
    16 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1);
    17 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
    18     ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ?{} */);
    19 }
    20 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
    21     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
    22 }
    23 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
    24     ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ^?{} */);
    25 }
    26 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     12static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     13static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     14static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
     15static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
     16static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1);
     17static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     18    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ?{} */);
     19}
     20static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     21    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
     22}
     23static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
     24    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ^?{} */);
     25}
     26static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
    2727    struct __anonymous0 ___ret__13s__anonymous0_1;
    28     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
    29     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
     28    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     29    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
    3030    return ___ret__13s__anonymous0_1;
    3131}
    32 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
    33     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
     32static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1){
     33    ((void)((*___dst__13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
    3434}
    3535volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
     
    3737    signed int __i__i_1;
    3838};
    39 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
    40 static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
    41 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
    42 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
    43 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1);
    44 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
    45     ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ?{} */);
    46 }
    47 static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
    48     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
    49 }
    50 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
    51     ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ^?{} */);
    52 }
    53 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     39static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
     40static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
     41static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
     42static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
     43static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1);
     44static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
     45    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ?{} */);
     46}
     47static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     48    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
     49}
     50static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
     51    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ^?{} */);
     52}
     53static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
    5454    struct __anonymous1 ___ret__13s__anonymous1_1;
    55     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
    56     ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__R13s__anonymous1_1)));
     55    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     56    ((void)___constructor__F_13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__13s__anonymous1_1)));
    5757    return ___ret__13s__anonymous1_1;
    5858}
    59 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
    60     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
     59static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1){
     60    ((void)((*___dst__13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
    6161}
    6262volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
     
    6464    signed int __i__i_1;
    6565};
    66 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
    67 static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
    68 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
    69 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
    70 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1);
    71 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
    72     ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ?{} */);
    73 }
    74 static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
    75     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
    76 }
    77 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
    78     ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ^?{} */);
    79 }
    80 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     66static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     67static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     68static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
     69static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
     70static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1);
     71static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     72    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ?{} */);
     73}
     74static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     75    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
     76}
     77static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
     78    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ^?{} */);
     79}
     80static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
    8181    struct __anonymous2 ___ret__13s__anonymous2_1;
    82     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
    83     ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__R13s__anonymous2_1)));
     82    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     83    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__anonymous2_1)));
    8484    return ___ret__13s__anonymous2_1;
    8585}
    86 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
    87     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
     86static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1){
     87    ((void)((*___dst__13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
    8888}
    8989volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
     
    9191    signed int __i__i_1;
    9292};
    93 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
    94 static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
    95 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
    96 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
    97 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1);
    98 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
    99     ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ?{} */);
    100 }
    101 static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
    102     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
    103 }
    104 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
    105     ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ^?{} */);
    106 }
    107 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     93static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
     94static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
     95static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
     96static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
     97static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1);
     98static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
     99    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ?{} */);
     100}
     101static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     102    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
     103}
     104static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
     105    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ^?{} */);
     106}
     107static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
    108108    struct __anonymous3 ___ret__13s__anonymous3_1;
    109     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
    110     ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__R13s__anonymous3_1)));
     109    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     110    ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__13s__anonymous3_1)));
    111111    return ___ret__13s__anonymous3_1;
    112112}
    113 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
    114     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
     113static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1){
     114    ((void)((*___dst__13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
    115115}
    116116static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
     
    118118    signed int __i__i_1;
    119119};
    120 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
    121 static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
    122 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
    123 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
    124 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1);
    125 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
    126     ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ?{} */);
    127 }
    128 static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
    129     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
    130 }
    131 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
    132     ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ^?{} */);
    133 }
    134 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     120static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
     121static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
     122static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
     123static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
     124static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1);
     125static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
     126    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ?{} */);
     127}
     128static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     129    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
     130}
     131static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
     132    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ^?{} */);
     133}
     134static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
    135135    struct __anonymous4 ___ret__13s__anonymous4_1;
    136     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
    137     ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__R13s__anonymous4_1)));
     136    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     137    ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__13s__anonymous4_1)));
    138138    return ___ret__13s__anonymous4_1;
    139139}
    140 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
    141     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
     140static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1){
     141    ((void)((*___dst__13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
    142142}
    143143static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
     
    145145    signed int __i__i_1;
    146146};
    147 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
    148 static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
    149 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
    150 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
    151 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1);
    152 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
    153     ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ?{} */);
    154 }
    155 static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
    156     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
    157 }
    158 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
    159     ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ^?{} */);
    160 }
    161 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     147static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
     148static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
     149static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
     150static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
     151static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1);
     152static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
     153    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ?{} */);
     154}
     155static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     156    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
     157}
     158static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
     159    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ^?{} */);
     160}
     161static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
    162162    struct __anonymous5 ___ret__13s__anonymous5_1;
    163     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
    164     ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__R13s__anonymous5_1)));
     163    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     164    ((void)___constructor__F_13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__13s__anonymous5_1)));
    165165    return ___ret__13s__anonymous5_1;
    166166}
    167 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
    168     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
     167static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1){
     168    ((void)((*___dst__13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
    169169}
    170170static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
     
    172172    signed int __i__i_1;
    173173};
    174 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
    175 static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
    176 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
    177 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
    178 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1);
    179 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
    180     ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ?{} */);
    181 }
    182 static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
    183     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
    184 }
    185 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
    186     ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ^?{} */);
    187 }
    188 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     174static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
     175static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
     176static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
     177static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
     178static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1);
     179static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
     180    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ?{} */);
     181}
     182static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     183    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
     184}
     185static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
     186    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ^?{} */);
     187}
     188static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
    189189    struct __anonymous6 ___ret__13s__anonymous6_1;
    190     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
    191     ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__R13s__anonymous6_1)));
     190    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     191    ((void)___constructor__F_13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__13s__anonymous6_1)));
    192192    return ___ret__13s__anonymous6_1;
    193193}
    194 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
    195     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
     194static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1){
     195    ((void)((*___dst__13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
    196196}
    197197static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
     
    199199    signed int __i__i_1;
    200200};
    201 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
    202 static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
    203 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
    204 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
    205 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1);
    206 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
    207     ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ?{} */);
    208 }
    209 static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
    210     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
    211 }
    212 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
    213     ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ^?{} */);
    214 }
    215 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     201static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
     202static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
     203static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
     204static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
     205static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1);
     206static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
     207    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ?{} */);
     208}
     209static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     210    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
     211}
     212static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
     213    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ^?{} */);
     214}
     215static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
    216216    struct __anonymous7 ___ret__13s__anonymous7_1;
    217     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
    218     ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__R13s__anonymous7_1)));
     217    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     218    ((void)___constructor__F_13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__13s__anonymous7_1)));
    219219    return ___ret__13s__anonymous7_1;
    220220}
    221 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
    222     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
     221static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1){
     222    ((void)((*___dst__13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
    223223}
    224224static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
     
    234234    signed short int __i__s_1;
    235235};
    236 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
    237 static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
    238 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
    239 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
    240 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1);
    241 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
    242     ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ?{} */);
    243 }
    244 static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
    245     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
    246 }
    247 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
    248     ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ^?{} */);
    249 }
    250 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     236static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
     237static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
     238static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
     239static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
     240static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1);
     241static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
     242    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ?{} */);
     243}
     244static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     245    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
     246}
     247static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
     248    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ^?{} */);
     249}
     250static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
    251251    struct __anonymous8 ___ret__13s__anonymous8_1;
    252     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
    253     ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__R13s__anonymous8_1)));
     252    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     253    ((void)___constructor__F_13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__13s__anonymous8_1)));
    254254    return ___ret__13s__anonymous8_1;
    255255}
    256 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
    257     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
     256static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1){
     257    ((void)((*___dst__13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
    258258}
    259259volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
     
    261261    signed short int __i__s_1;
    262262};
    263 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
    264 static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
    265 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
    266 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
    267 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1);
    268 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
    269     ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ?{} */);
    270 }
    271 static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
    272     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
    273 }
    274 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
    275     ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ^?{} */);
    276 }
    277 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     263static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
     264static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
     265static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
     266static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
     267static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1);
     268static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
     269    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ?{} */);
     270}
     271static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     272    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
     273}
     274static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
     275    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ^?{} */);
     276}
     277static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
    278278    struct __anonymous9 ___ret__13s__anonymous9_1;
    279     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
    280     ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__R13s__anonymous9_1)));
     279    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     280    ((void)___constructor__F_13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__13s__anonymous9_1)));
    281281    return ___ret__13s__anonymous9_1;
    282282}
    283 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
    284     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
     283static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1){
     284    ((void)((*___dst__13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
    285285}
    286286volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
     
    288288    signed short int __i__s_1;
    289289};
    290 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
    291 static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
    292 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
    293 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
    294 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1);
    295 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
    296     ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ?{} */);
    297 }
    298 static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
    299     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
    300 }
    301 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
    302     ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ^?{} */);
    303 }
    304 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     290static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
     291static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
     292static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
     293static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
     294static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1);
     295static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
     296    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ?{} */);
     297}
     298static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     299    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
     300}
     301static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
     302    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ^?{} */);
     303}
     304static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
    305305    struct __anonymous10 ___ret__14s__anonymous10_1;
    306     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
    307     ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__R14s__anonymous10_1)));
     306    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     307    ((void)___constructor__F_14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__14s__anonymous10_1)));
    308308    return ___ret__14s__anonymous10_1;
    309309}
    310 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
    311     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
     310static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1){
     311    ((void)((*___dst__14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
    312312}
    313313volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
     
    315315    signed short int __i__s_1;
    316316};
    317 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
    318 static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
    319 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
    320 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
    321 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1);
    322 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
    323     ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ?{} */);
    324 }
    325 static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
    326     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
    327 }
    328 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
    329     ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ^?{} */);
    330 }
    331 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     317static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
     318static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
     319static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
     320static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
     321static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1);
     322static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
     323    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ?{} */);
     324}
     325static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     326    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
     327}
     328static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
     329    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ^?{} */);
     330}
     331static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
    332332    struct __anonymous11 ___ret__14s__anonymous11_1;
    333     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
    334     ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__R14s__anonymous11_1)));
     333    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     334    ((void)___constructor__F_14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__14s__anonymous11_1)));
    335335    return ___ret__14s__anonymous11_1;
    336336}
    337 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
    338     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
     337static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1){
     338    ((void)((*___dst__14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
    339339}
    340340static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
     
    342342    signed short int __i__s_1;
    343343};
    344 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
    345 static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
    346 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
    347 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
    348 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1);
    349 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
    350     ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ?{} */);
    351 }
    352 static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
    353     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
    354 }
    355 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
    356     ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ^?{} */);
    357 }
    358 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     344static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
     345static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
     346static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
     347static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
     348static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1);
     349static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
     350    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ?{} */);
     351}
     352static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     353    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
     354}
     355static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
     356    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ^?{} */);
     357}
     358static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
    359359    struct __anonymous12 ___ret__14s__anonymous12_1;
    360     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
    361     ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__R14s__anonymous12_1)));
     360    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     361    ((void)___constructor__F_14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__14s__anonymous12_1)));
    362362    return ___ret__14s__anonymous12_1;
    363363}
    364 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
    365     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
     364static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1){
     365    ((void)((*___dst__14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
    366366}
    367367static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
     
    369369    signed short int __i__s_1;
    370370};
    371 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
    372 static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
    373 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
    374 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
    375 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1);
    376 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
    377     ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ?{} */);
    378 }
    379 static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
    380     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
    381 }
    382 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
    383     ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ^?{} */);
    384 }
    385 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     371static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
     372static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
     373static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
     374static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
     375static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1);
     376static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
     377    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ?{} */);
     378}
     379static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     380    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
     381}
     382static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
     383    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ^?{} */);
     384}
     385static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
    386386    struct __anonymous13 ___ret__14s__anonymous13_1;
    387     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
    388     ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__R14s__anonymous13_1)));
     387    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     388    ((void)___constructor__F_14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__14s__anonymous13_1)));
    389389    return ___ret__14s__anonymous13_1;
    390390}
    391 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
    392     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
     391static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1){
     392    ((void)((*___dst__14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
    393393}
    394394static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
     
    396396    signed short int __i__s_1;
    397397};
    398 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
    399 static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
    400 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
    401 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
    402 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1);
    403 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
    404     ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ?{} */);
    405 }
    406 static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymo