Changeset 8024bc8


Ignore:
Timestamp:
Sep 18, 2017, 11:02:23 AM (4 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, resolv-new, with_gc
Children:
6994d8c
Parents:
ed235b6 (diff), 5f782f7 (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:
20 edited

Legend:

Unmodified
Added
Removed
  • src/Common/PassVisitor.impl.h

    red235b6 r8024bc8  
    6666        DeclList_t* beforeDecls = visitor.get_beforeDecls();
    6767        DeclList_t* afterDecls  = visitor.get_afterDecls();
     68        SemanticError errors;
    6869
    6970        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
     
    7374                if ( i == decls.end() ) break;
    7475
    75                 // run mutator on declaration
    76                 maybeAccept( *i, visitor );
     76                try {
     77                        // run visitor on declaration
     78                        maybeAccept( *i, visitor );
     79                } catch( SemanticError &e ) {
     80                        e.set_location( (*i)->location );
     81                        errors.append( e );
     82                }
    7783
    7884                // splice in new declarations before current decl
    7985                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
    8086        }
     87        if ( ! errors.isEmpty() ) {
     88                throw errors;
     89        }
    8190}
    8291
     
    8695        DeclList_t* beforeDecls = mutator.get_beforeDecls();
    8796        DeclList_t* afterDecls  = mutator.get_afterDecls();
     97        SemanticError errors;
    8898
    8999        for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
     
    92102
    93103                if ( i == decls.end() ) break;
    94 
    95                 // run mutator on declaration
    96                 *i = maybeMutate( *i, mutator );
     104                try {
     105                        // run mutator on declaration
     106                        *i = maybeMutate( *i, mutator );
     107                } catch( SemanticError &e ) {
     108                        e.set_location( (*i)->location );
     109                        errors.append( e );
     110                }
    97111
    98112                // splice in new declarations before current decl
    99113                if ( !empty( beforeDecls ) ) { decls.splice( i, *beforeDecls ); }
     114        }
     115        if ( ! errors.isEmpty() ) {
     116                throw errors;
    100117        }
    101118}
     
    166183
    167184                } catch ( SemanticError &e ) {
     185                        e.set_location( (*i)->location );
    168186                        errors.append( e );
    169187                }
     
    275293//------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    276294
     295// A NOTE ON THE ORDER OF TRAVERSAL
     296//
     297// Types and typedefs have their base types visited before they are added to the type table.  This is ok, since there is
     298// no such thing as a recursive type or typedef.
     299//
     300//             typedef struct { T *x; } T; // never allowed
     301//
     302// for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
     303// members are traversed, and then the complete type should be added (assuming the type is completed by this particular
     304// declaration).
     305//
     306//             struct T { struct T *x; }; // allowed
     307//
     308// It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
     309// traversal may modify the definition of the type and these modifications should be visible when the symbol table is
     310// queried later in this pass.
     311//
     312// TODO: figure out whether recursive contexts are sensible/possible/reasonable.
    277313
    278314//--------------------------------------------------------------------------
     
    432468        indexerAddEnum( node );
    433469
    434         // unlike structs, contexts, and unions, enums inject their members into the global scope
     470        // unlike structs, traits, and unions, enums inject their members into the global scope
    435471        maybeAccept( node->parameters, *this );
    436472        maybeAccept( node->members   , *this );
     
    445481        indexerAddEnum( node );
    446482
    447         // unlike structs, contexts, and unions, enums inject their members into the global scope
     483        // unlike structs, traits, and unions, enums inject their members into the global scope
    448484        maybeMutateRef( node->parameters, *this );
    449485        maybeMutateRef( node->members   , *this );
     
    496532        }
    497533
     534        // see A NOTE ON THE ORDER OF TRAVERSAL, above
     535        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
     536        // and may depend on the type itself
    498537        indexerAddType( node );
    499538
     
    515554        }
    516555
     556        // see A NOTE ON THE ORDER OF TRAVERSAL, above
     557        // note that assertions come after the type is added to the symtab, since they are not part of the type proper
     558        // and may depend on the type itself
    517559        indexerAddType( node );
    518560
     
    641683void PassVisitor< pass_type >::visit( IfStmt * node ) {
    642684        VISIT_START( node );
    643 
    644         visitExpression( node->condition );
    645         node->thenPart = visitStatement( node->thenPart );
    646         node->elsePart = visitStatement( node->elsePart );
    647 
     685        {
     686                // if statements introduce a level of scope (for the initialization)
     687                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     688                acceptAll( node->get_initialization(), *this );
     689                visitExpression( node->condition );
     690                node->thenPart = visitStatement( node->thenPart );
     691                node->elsePart = visitStatement( node->elsePart );
     692        }
    648693        VISIT_END( node );
    649694}
     
    653698        MUTATE_START( node );
    654699        {
    655                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     700                // if statements introduce a level of scope (for the initialization)
     701                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     702                maybeMutateRef( node->get_initialization(), *this );
    656703                node->condition = mutateExpression( node->condition );
    657704                node->thenPart  = mutateStatement ( node->thenPart  );
     
    689736        VISIT_START( node );
    690737        {
     738                // for statements introduce a level of scope (for the initialization)
    691739                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    692740                maybeAccept( node->initialization, *this );
     
    702750        MUTATE_START( node );
    703751        {
     752                // for statements introduce a level of scope (for the initialization)
    704753                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    705754                maybeMutateRef( node->initialization, *this );
     
    830879        VISIT_START( node );
    831880        {
     881                // catch statements introduce a level of scope (for the caught exception)
    832882                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    833883                maybeAccept( node->decl, *this );
     
    842892        MUTATE_START( node );
    843893        {
     894                // catch statements introduce a level of scope (for the caught exception)
    844895                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
    845896                maybeMutateRef( node->decl, *this );
  • src/Common/PassVisitor.proto.h

    red235b6 r8024bc8  
    179179
    180180template<typename pass_type>
    181 static inline auto indexer_impl_enterScope( pass_type &, int ) {}
     181static inline auto indexer_impl_enterScope( pass_type &, long ) {}
    182182
    183183template<typename pass_type>
     
    187187
    188188template<typename pass_type>
    189 static inline auto indexer_impl_leaveScope( pass_type &, int ) {}
     189static inline auto indexer_impl_leaveScope( pass_type &, long ) {}
    190190
    191191
     
    197197                                                                                                                               \
    198198template<typename pass_type>                                                                                                   \
    199 static inline void indexer_impl_##func ( pass_type &, long, type ) {}                                                          \
     199static inline void indexer_impl_##func ( pass_type &, long, type ) { }                                                          \
    200200
    201201INDEXER_FUNC( addId     , DeclarationWithType * );
     
    215215
    216216template<typename pass_type>
    217 static inline auto indexer_impl_addStructFwd( pass_type &, int, StructDecl * ) {}
     217static inline auto indexer_impl_addStructFwd( pass_type &, long, StructDecl * ) {}
    218218
    219219template<typename pass_type>
     
    225225
    226226template<typename pass_type>
    227 static inline auto indexer_impl_addUnionFwd( pass_type &, int, UnionDecl * ) {}
     227static inline auto indexer_impl_addUnionFwd( pass_type &, long, UnionDecl * ) {}
    228228
    229229template<typename pass_type>
     
    235235
    236236template<typename pass_type>
    237 static inline auto indexer_impl_addStruct( pass_type &, int, const std::string & ) {}
     237static inline auto indexer_impl_addStruct( pass_type &, long, const std::string & ) {}
    238238
    239239template<typename pass_type>
     
    245245
    246246template<typename pass_type>
    247 static inline auto indexer_impl_addUnion( pass_type &, int, const std::string & ) {}
     247static inline auto indexer_impl_addUnion( pass_type &, long, const std::string & ) {}
  • src/GenPoly/Box.cc

    red235b6 r8024bc8  
    628628                                        } else {
    629629                                                // xxx - should this be an assertion?
    630                                                 std::string x = env ? toString( *env ) : "missing env";
    631                                                 throw SemanticError( x + "\n" + "unbound type variable: " + tyParm->first + " in application ", appExpr );
     630                                                throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr );
    632631                                        } // if
    633632                                } // if
     
    706705                                if ( concrete == 0 ) {
    707706                                        return typeInst;
    708                                         // xxx - should this be an assertion?
    709 //                                      std::string x = env ? toString( *env ) : "missing env";
    710 //                                      throw SemanticError( x + "\n" + "Unbound type variable " + typeInst->get_name() + " in ", appExpr );
    711707                                } // if
    712708                                return concrete;
  • src/InitTweak/FixInit.cc

    red235b6 r8024bc8  
    7070namespace InitTweak {
    7171        namespace {
    72                 typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
    7372                typedef std::unordered_map< int, int > UnqCount;
    7473
    75                 class InsertImplicitCalls : public WithTypeSubstitution {
    76                 public:
     74                struct InsertImplicitCalls : public WithTypeSubstitution {
    7775                        /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
    7876                        /// function calls need their parameters to be copy constructed
    79                         static void insert( std::list< Declaration * > & translationUnit, EnvMap & envMap );
    80 
    81                         InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
     77                        static void insert( std::list< Declaration * > & translationUnit );
    8278
    8379                        Expression * postmutate( ApplicationExpr * appExpr );
    84                         void premutate( StmtExpr * stmtExpr );
    85 
    86                         // collects environments for relevant nodes
    87                         EnvMap & envMap;
    8880                };
    8981
    90                 class ResolveCopyCtors final : public SymTab::Indexer {
    91                 public:
     82                struct ResolveCopyCtors final : public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution {
    9283                        /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
    9384                        /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
    9485                        /// arguments and return value temporaries
    95                         static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount );
    96 
    97                         typedef SymTab::Indexer Parent;
    98                         using Parent::visit;
    99 
    100                         ResolveCopyCtors( const EnvMap & envMap, UnqCount & unqCount ) : envMap( envMap ), unqCount( unqCount ) {}
    101 
    102                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
    103                         virtual void visit( UniqueExpr * unqExpr ) override;
    104                         virtual void visit( StmtExpr * stmtExpr ) override;
     86                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount );
     87
     88                        ResolveCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ) {}
     89
     90                        void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr );
     91                        void postvisit( StmtExpr * stmtExpr );
     92                        void previsit( UniqueExpr * unqExpr );
     93                        void postvisit( UniqueExpr * unqExpr );
    10594
    10695                        /// create and resolve ctor/dtor expression: fname(var, [cpArg])
     
    111100                        void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
    112101
    113                         TypeSubstitution * env;
    114                         const EnvMap & envMap;
    115102                        UnqCount & unqCount; // count the number of times each unique expr ID appears
     103                        std::unordered_set< int > vars;
    116104                };
    117105
     
    238226                };
    239227
    240                 class GenStructMemberCalls final : public SymTab::Indexer {
    241                   public:
    242                         typedef Indexer Parent;
     228                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
    243229                        /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
    244230                        /// for any member that is missing a corresponding ctor/dtor call.
     
    246232                        static void generate( std::list< Declaration * > & translationUnit );
    247233
    248                         using Parent::visit;
    249 
    250                         virtual void visit( FunctionDecl * funcDecl ) override;
    251 
    252                         virtual void visit( MemberExpr * memberExpr ) override;
    253                         virtual void visit( ApplicationExpr * appExpr ) override;
     234                        void previsit( FunctionDecl * funcDecl );
     235                        void postvisit( FunctionDecl * funcDecl );
     236
     237                        void previsit( MemberExpr * memberExpr );
     238                        void previsit( ApplicationExpr * appExpr );
    254239
    255240                        SemanticError errors;
     
    295280                InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
    296281
    297                 EnvMap envMap;
    298282                UnqCount unqCount;
    299283
    300                 InsertImplicitCalls::insert( translationUnit, envMap );
    301                 ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap, unqCount );
     284                InsertImplicitCalls::insert( translationUnit );
     285                ResolveCopyCtors::resolveImplicitCalls( translationUnit, unqCount );
    302286                InsertDtors::insert( translationUnit );
    303287                FixInit::fixInitializers( translationUnit );
     
    318302
    319303        namespace {
    320                 void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
    321                         PassVisitor<InsertImplicitCalls> inserter( envMap );
     304                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
     305                        PassVisitor<InsertImplicitCalls> inserter;
    322306                        mutateAll( translationUnit, inserter );
    323307                }
    324308
    325                 void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount ) {
    326                         ResolveCopyCtors resolver( envMap, unqCount );
     309                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
     310                        PassVisitor<ResolveCopyCtors> resolver( unqCount );
    327311                        acceptAll( translationUnit, resolver );
    328312                }
     
    360344
    361345                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
    362                         GenStructMemberCalls warner;
     346                        PassVisitor<GenStructMemberCalls> warner;
    363347                        acceptAll( translationUnit, warner );
    364348                }
     
    398382                        // wrap each function call so that it is easy to identify nodes that have to be copy constructed
    399383                        ImplicitCopyCtorExpr * expr = new ImplicitCopyCtorExpr( appExpr );
    400                         // save the type substitution into the envMap so that it is easy to find.
     384                        // Move the type substitution to the new top-level, if it is attached to the appExpr.
    401385                        // Ensure it is not deleted with the ImplicitCopyCtorExpr by removing it before deletion.
    402386                        // The substitution is needed to obtain the type of temporary variables so that copy constructor
    403                         // calls can be resolved. Normally this is what PolyMutator is for, but the pass that resolves
    404                         // copy constructor calls must be an Indexer. We could alternatively make a PolyIndexer which
    405                         // saves the environment, or compute the types of temporaries here, but it's much simpler to
    406                         // save the environment here, and more cohesive to compute temporary variables and resolve copy
    407                         // constructor calls together.
     387                        // calls can be resolved.
    408388                        assert( env );
    409                         envMap[expr] = env;
     389                        std::swap( expr->env, appExpr->env );
    410390                        return expr;
    411                 }
    412 
    413                 void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) {
    414                         assert( env );
    415                         envMap[stmtExpr] = env;
    416391                }
    417392
     
    431406                        // (VariableExpr and already resolved expression)
    432407                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
    433                         Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
     408                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
    434409                        assert( resolved );
    435410                        if ( resolved->get_env() ) {
     
    480455                }
    481456
    482                 void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
     457                void ResolveCopyCtors::postvisit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
    483458                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
    484                         Parent::visit( impCpCtorExpr );
    485                         env = envMap.at(impCpCtorExpr);
    486                         assert( env );
    487459
    488460                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
     
    513485                }
    514486
    515                 void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
    516                         Parent::visit( stmtExpr );
    517                         env = envMap.at(stmtExpr);
     487                void ResolveCopyCtors::postvisit( StmtExpr * stmtExpr ) {
     488                        assert( env );
    518489                        assert( stmtExpr->get_result() );
    519490                        Type * result = stmtExpr->get_result();
     
    537508                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
    538509                        } // if
    539 
    540                 }
    541 
    542                 void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
    543                         static std::unordered_set< int > vars;
     510                }
     511
     512                void ResolveCopyCtors::previsit( UniqueExpr * unqExpr ) {
    544513                        unqCount[ unqExpr->get_id() ]++;  // count the number of unique expressions for each ID
    545514                        if ( vars.count( unqExpr->get_id() ) ) {
    546515                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
     516                                visit_children = false;
     517                        }
     518                }
     519
     520                void ResolveCopyCtors::postvisit( UniqueExpr * unqExpr ) {
     521                        if ( vars.count( unqExpr->get_id() ) ) {
     522                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
    547523                                return;
    548524                        }
    549525
    550                         Parent::visit( unqExpr );
    551526                        // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
    552527                        assert( unqExpr->get_result() );
     
    585560
    586561                        // xxx - update to work with multiple return values
    587                         ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front();
     562                        ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
    588563                        Expression * callExpr = impCpCtorExpr->get_callExpr();
    589564
     
    594569                        tempDecls.clear();
    595570                        returnDecls.clear();
    596                         impCpCtorExpr->set_callExpr( NULL );
    597                         impCpCtorExpr->set_env( NULL );
     571                        impCpCtorExpr->set_callExpr( nullptr );
     572                        std::swap( impCpCtorExpr->env, callExpr->env );
     573                        assert( impCpCtorExpr->env == nullptr );
    598574                        delete impCpCtorExpr;
    599575
     
    978954                }
    979955
    980                 void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
    981                         ValueGuard< FunctionDecl * > oldFunction( funcDecl );
    982                         ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
    983                         ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
    984                         ValueGuard< ObjectDecl * > oldThisParam( thisParam );
    985                         ValueGuard< bool > oldIsCtor( isCtor );
    986                         ValueGuard< StructDecl * > oldStructDecl( structDecl );
     956                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
     957                        GuardValue( funcDecl );
     958                        GuardValue( unhandled );
     959                        GuardValue( usedUninit );
     960                        GuardValue( thisParam );
     961                        GuardValue( isCtor );
     962                        GuardValue( structDecl );
    987963                        errors = SemanticError();  // clear previous errors
    988964
     
    1010986                                }
    1011987                        }
    1012                         Parent::visit( function );
    1013 
     988                }
     989
     990                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
     991                        for ( auto d : decls ) {
     992                                indexer.addId( d );
     993                        }
     994                }
     995
     996                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
     997                        for ( auto td : tds ) {
     998                                indexer.addType( td );
     999                                addIds( indexer, td->assertions );
     1000                        }
     1001                }
     1002
     1003                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
    10141004                        // remove the unhandled objects from usedUninit, because a call is inserted
    10151005                        // to handle them - only objects that are later constructed are used uninitialized.
     
    10321022                        if ( ! unhandled.empty() ) {
    10331023                                // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
    1034                                 enterScope();
    1035                                 maybeAccept( function->get_functionType(), *this );
     1024                                auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
     1025                                addTypes( indexer, function->type->forall );
     1026                                addIds( indexer, function->type->returnVals );
     1027                                addIds( indexer, function->type->parameters );
    10361028
    10371029                                // need to iterate through members in reverse in order for
     
    10631055                                                Statement * callStmt = stmt.front();
    10641056
    1065                                                 MutatingResolver resolver( *this );
     1057                                                MutatingResolver resolver( indexer );
    10661058                                                try {
    10671059                                                        callStmt->acceptMutator( resolver );
     
    10771069                                        }
    10781070                                }
    1079                                 leaveScope();
    10801071                        }
    10811072                        if (! errors.isEmpty()) {
     
    11071098                }
    11081099
    1109                 void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
    1110                         if ( ! checkWarnings( function ) ) return;
     1100                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
     1101                        if ( ! checkWarnings( function ) ) {
     1102                                visit_children = false;
     1103                                return;
     1104                        }
    11111105
    11121106                        std::string fname = getFunctionName( appExpr );
     
    11271121                                }
    11281122                        }
    1129                         Parent::visit( appExpr );
    1130                 }
    1131 
    1132                 void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
    1133                         if ( ! checkWarnings( function ) ) return;
    1134                         if ( ! isCtor ) return;
     1123                }
     1124
     1125                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
     1126                        if ( ! checkWarnings( function ) || ! isCtor ) {
     1127                                visit_children = false;
     1128                                return;
     1129                        }
    11351130
    11361131                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
     
    11401135                                }
    11411136                        }
    1142                         Parent::visit( memberExpr );
    11431137                }
    11441138
     
    11611155                        // in generated code. If this changes, add mutate methods for entities with
    11621156                        // scope and call {enter,leave}Scope explicitly.
    1163                         objectDecl->accept( indexer );
     1157                        indexer.addId( objectDecl );
    11641158                        return objectDecl;
    11651159                }
  • src/Parser/ExpressionNode.cc

    red235b6 r8024bc8  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Sep 12 10:00:29 2017
    13 // Update Count     : 672
     12// Last Modified On : Thu Sep 14 23:09:34 2017
     13// Update Count     : 690
    1414//
    1515
     
    250250        sepString( str, units, '"' );                                           // separate constant from units
    251251
    252         BasicType::Kind strtype = BasicType::Char;                      // default string type
    253         switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string ""
     252        Type * strtype;
     253        switch ( str[0] ) {                                                                     // str has >= 2 characters, i.e, null string "" => safe to look at subscripts 0/1
    254254          case 'u':
    255                 if ( str[1] == '8' ) break;                                             // utf-8 characters
    256                 strtype = BasicType::ShortUnsignedInt;
     255                if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
     256                // lookup type of associated typedef
     257                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char16_t", false );
    257258                break;
    258259          case 'U':
    259                 strtype = BasicType::UnsignedInt;
     260                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char32_t", false );
    260261                break;
    261262          case 'L':
    262                 strtype = BasicType::SignedInt;
     263                strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "wchar_t", false );
    263264                break;
     265          Default:                                                                                      // char default string type
     266          default:
     267                strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
    264268        } // switch
    265         ArrayType * at = new ArrayType( noQualifiers, new BasicType( Type::Qualifiers( Type::Const ), strtype ),
     269        ArrayType * at = new ArrayType( noQualifiers, strtype,
    266270                                                                        new ConstantExpr( Constant::from_ulong( str.size() + 1 - 2 ) ), // +1 for '\0' and -2 for '"'
    267271                                                                        false, false );
     
    344348
    345349Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {
    346         Type * targetType = maybeMoveBuildType( decl_node );
    347         Expression * castArg = maybeMoveBuild< Expression >( expr_node );
    348         return new VirtualCastExpr( castArg, targetType );
     350        return new VirtualCastExpr( maybeMoveBuild< Expression >( expr_node ), maybeMoveBuildType( decl_node ) );
    349351} // build_virtual_cast
    350352
    351353Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member ) {
    352         UntypedMemberExpr * ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
    353         return ret;
     354        return new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
    354355} // build_fieldSel
    355356
     
    361362        return ret;
    362363} // build_pfieldSel
    363 
    364 Expression * build_addressOf( ExpressionNode * expr_node ) {
    365                 return new AddressExpr( maybeMoveBuild< Expression >(expr_node) );
    366 } // build_addressOf
    367 
    368 Expression * build_sizeOfexpr( ExpressionNode * expr_node ) {
    369         return new SizeofExpr( maybeMoveBuild< Expression >(expr_node) );
    370 } // build_sizeOfexpr
    371 
    372 Expression * build_sizeOftype( DeclarationNode * decl_node ) {
    373         return new SizeofExpr( maybeMoveBuildType( decl_node ) );
    374 } // build_sizeOftype
    375 
    376 Expression * build_alignOfexpr( ExpressionNode * expr_node ) {
    377         return new AlignofExpr( maybeMoveBuild< Expression >(expr_node) );
    378 } // build_alignOfexpr
    379 
    380 Expression * build_alignOftype( DeclarationNode * decl_node ) {
    381         return new AlignofExpr( maybeMoveBuildType( decl_node) );
    382 } // build_alignOftype
    383364
    384365Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member ) {
     
    422403} // build_cond
    423404
    424 Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
    425         return new CommaExpr( maybeMoveBuild< Expression >(expr_node1), maybeMoveBuild< Expression >(expr_node2) );
    426 } // build_comma
    427 
    428 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node ) {
    429         return new AttrExpr( var, maybeMoveBuild< Expression >(expr_node) );
    430 } // build_attrexpr
    431 
    432 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node ) {
    433         return new AttrExpr( var, maybeMoveBuildType( decl_node ) );
    434 } // build_attrtype
    435 
    436405Expression * build_tuple( ExpressionNode * expr_node ) {
    437406        list< Expression * > exprs;
     
    445414        return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
    446415} // build_func
    447 
    448 Expression * build_range( ExpressionNode * low, ExpressionNode * high ) {
    449         return new RangeExpr( maybeMoveBuild< Expression >( low ), maybeMoveBuild< Expression >( high ) );
    450 } // build_range
    451 
    452 Expression * build_asmexpr( ExpressionNode * inout, Expression * constraint, ExpressionNode * operand ) {
    453         return new AsmExpr( maybeMoveBuild< Expression >( inout ), constraint, maybeMoveBuild< Expression >(operand) );
    454 } // build_asmexpr
    455 
    456 Expression * build_valexpr( StatementNode * s ) {
    457         return new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(s) ) );
    458 } // build_valexpr
    459 
    460 Expression * build_typevalue( DeclarationNode * decl ) {
    461         return new TypeExpr( maybeMoveBuildType( decl ) );
    462 } // build_typevalue
    463416
    464417Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids ) {
  • src/Parser/ParseNode.h

    red235b6 r8024bc8  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Sep 10 09:56:32 2017
    13 // Update Count     : 801
     12// Last Modified On : Thu Sep 14 23:09:39 2017
     13// Update Count     : 815
    1414//
    1515
     
    122122
    123123        template<typename T>
    124         bool isExpressionType() const {
    125                 return nullptr != dynamic_cast<T>(expr.get());
    126         }
     124        bool isExpressionType() const { return nullptr != dynamic_cast<T>(expr.get()); }
    127125
    128126        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
     
    172170
    173171NameExpr * build_varref( const std::string * name );
    174 Expression * build_typevalue( DeclarationNode * decl );
    175172
    176173Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
     
    178175Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
    179176Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
    180 Expression * build_addressOf( ExpressionNode * expr_node );
    181 Expression * build_sizeOfexpr( ExpressionNode * expr_node );
    182 Expression * build_sizeOftype( DeclarationNode * decl_node );
    183 Expression * build_alignOfexpr( ExpressionNode * expr_node );
    184 Expression * build_alignOftype( DeclarationNode * decl_node );
    185177Expression * build_offsetOf( DeclarationNode * decl_node, NameExpr * member );
    186178Expression * build_and( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
     
    191183Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
    192184Expression * build_cond( ExpressionNode * expr_node1, ExpressionNode * expr_node2, ExpressionNode * expr_node3 );
    193 Expression * build_comma( ExpressionNode * expr_node1, ExpressionNode * expr_node2 );
    194 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
    195 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
    196185Expression * build_tuple( ExpressionNode * expr_node = nullptr );
    197186Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
    198 Expression * build_range( ExpressionNode * low, ExpressionNode * high );
    199 Expression * build_asmexpr( ExpressionNode * inout, Expression * constraint, ExpressionNode * operand );
    200 Expression * build_valexpr( StatementNode * s );
    201187Expression * build_compoundLiteral( DeclarationNode * decl_node, InitializerNode * kids );
    202188
  • src/Parser/parser.yy

    red235b6 r8024bc8  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 11 18:12:00 2017
    13 // Update Count     : 2787
     12// Last Modified On : Thu Sep 14 23:07:12 2017
     13// Update Count     : 2815
    1414//
    1515
     
    5656#include "LinkageSpec.h"
    5757#include "Common/SemanticError.h"                                               // error_str
     58#include "Common/utility.h"                                                             // for maybeMoveBuild, maybeBuild, CodeLo...
    5859
    5960extern DeclarationNode * parseTree;
     
    438439                { $$ = $2; }
    439440        | '(' compound_statement ')'                                            // GCC, lambda expression
    440                 { $$ = new ExpressionNode( build_valexpr( $2 ) ); }
     441                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
    441442        | primary_expression '{' argument_expression_list '}' // CFA, constructor call
    442443                {
     
    562563                        switch ( $1 ) {
    563564                          case OperKinds::AddressOf:
    564                                 $$ = new ExpressionNode( build_addressOf( $2 ) );
     565                                $$ = new ExpressionNode( new AddressExpr( maybeMoveBuild< Expression >( $2 ) ) );
    565566                                break;
    566567                          case OperKinds::PointTo:
     
    568569                                break;
    569570                          case OperKinds::And:
    570                                 $$ = new ExpressionNode( new AddressExpr( build_addressOf( $2 ) ) );
     571                                $$ = new ExpressionNode( new AddressExpr( new AddressExpr( maybeMoveBuild< Expression >( $2 ) ) ) );
    571572                                break;
    572573                          default:
     
    581582                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
    582583        | SIZEOF unary_expression
    583                 { $$ = new ExpressionNode( build_sizeOfexpr( $2 ) ); }
     584                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuild< Expression >( $2 ) ) ); }
    584585        | SIZEOF '(' type_no_function ')'
    585                 { $$ = new ExpressionNode( build_sizeOftype( $3 ) ); }
     586                { $$ = new ExpressionNode( new SizeofExpr( maybeMoveBuildType( $3 ) ) ); }
    586587        | ALIGNOF unary_expression                                                      // GCC, variable alignment
    587                 { $$ = new ExpressionNode( build_alignOfexpr( $2 ) ); }
     588                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuild< Expression >( $2 ) ) ); }
    588589        | ALIGNOF '(' type_no_function ')'                                      // GCC, type alignment
    589                 { $$ = new ExpressionNode( build_alignOftype( $3 ) ); }
     590                { $$ = new ExpressionNode( new AlignofExpr( maybeMoveBuildType( $3 ) ) ); }
    590591        | OFFSETOF '(' type_no_function ',' no_attr_identifier ')'
    591592                { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
    592593        | ATTR_IDENTIFIER
    593                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), nullptr ) ); }
     594                { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuild< Expression >( (ExpressionNode *)nullptr ) ) ); }
    594595        | ATTR_IDENTIFIER '(' argument_expression ')'
    595                 { $$ = new ExpressionNode( build_attrexpr( build_varref( $1 ), $3 ) ); }
     596                { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
    596597        | ATTR_IDENTIFIER '(' type ')'
    597                 { $$ = new ExpressionNode( build_attrtype( build_varref( $1 ), $3 ) ); }
     598                { $$ = new ExpressionNode( new AttrExpr( build_varref( $1 ), maybeMoveBuildType( $3 ) ) ); }
    598599        ;
    599600
     
    618619                // VIRTUAL cannot be opt because of look ahead issues
    619620        | '(' VIRTUAL ')' cast_expression
    620                 { $$ = new ExpressionNode( build_virtual_cast( nullptr, $4 ) ); }
     621                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $4 ), maybeMoveBuildType( nullptr ) ) ); }
    621622        | '(' VIRTUAL type_no_function ')' cast_expression
    622                 { $$ = new ExpressionNode( build_virtual_cast( $3, $5 ) ); }
     623                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $5 ), maybeMoveBuildType( $3 ) ) ); }
    623624//      | '(' type_no_function ')' tuple
    624625//              { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
     
    771772        assignment_expression
    772773        | comma_expression ',' assignment_expression
    773                 { $$ = new ExpressionNode( build_comma( $1, $3 ) ); }
     774                { $$ = new ExpressionNode( new CommaExpr( maybeMoveBuild< Expression >( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
    774775        ;
    775776
     
    894895        constant_expression                                                     { $$ = $1; }
    895896        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
    896                 { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
     897                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
    897898        | subrange                                                                                      // CFA, subrange
    898899        ;
     
    11541155asm_operand:                                                                                    // GCC
    11551156        string_literal '(' constant_expression ')'
    1156                 { $$ = new ExpressionNode( build_asmexpr( 0, $1, $3 ) ); }
     1157                { $$ = new ExpressionNode( new AsmExpr( maybeMoveBuild< Expression >( (ExpressionNode *)nullptr ), $1, maybeMoveBuild< Expression >( $3 ) ) ); }
    11571158        | '[' constant_expression ']' string_literal '(' constant_expression ')'
    1158                 { $$ = new ExpressionNode( build_asmexpr( $2, $4, $6 ) ); }
     1159                { $$ = new ExpressionNode( new AsmExpr( maybeMoveBuild< Expression >( $2 ), $4, maybeMoveBuild< Expression >( $6 ) ) ); }
    11591160        ;
    11601161
     
    11651166                { $$ = new ExpressionNode( $1 ); }
    11661167        | asm_clobbers_list_opt ',' string_literal
    1167                 // set_last return ParseNode *
     1168                // set_last returns ParseNode *
    11681169                { $$ = (ExpressionNode *)$1->set_last( new ExpressionNode( $3 ) ); }
    11691170        ;
     
    20882089                { $$ = $3; }
    20892090        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    2090                 { $$ = new ExpressionNode( build_range( $3, $5 ) ); }
     2091                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $3 ), maybeMoveBuild< Expression >( $5 ) ) ); }
    20912092        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    20922093                { $$ = $4; }
     
    21652166type_list:                                                                                              // CFA
    21662167        type
    2167                 { $$ = new ExpressionNode( build_typevalue( $1 ) ); }
     2168                { $$ = new ExpressionNode( new TypeExpr( maybeMoveBuildType( $1 ) ) ); }
    21682169        | assignment_expression
    21692170        | type_list ',' type
    2170                 { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( build_typevalue( $3 ) ) ) ); }
     2171                { $$ = (ExpressionNode *)( $1->set_last( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ) ) ); }
    21712172        | type_list ',' assignment_expression
    21722173                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
     
    24062407subrange:
    24072408        constant_expression '~' constant_expression                     // CFA, integer subrange
    2408                 { $$ = new ExpressionNode( build_range( $1, $3 ) ); }
     2409                { $$ = new ExpressionNode( new RangeExpr( maybeMoveBuild< Expression >( $1 ), maybeMoveBuild< Expression >( $3 ) ) ); }
    24092410        ;
    24102411
  • src/ResolvExpr/AlternativeFinder.cc

    red235b6 r8024bc8  
    523523                for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
    524524                        if ( i->second.isUsed ) {
    525                                 i->first->accept( indexer );
     525                                indexer.addId( i->first );
    526526                        }
    527527                }
  • src/ResolvExpr/AlternativePrinter.cc

    red235b6 r8024bc8  
    2626
    2727namespace ResolvExpr {
    28         AlternativePrinter::AlternativePrinter( std::ostream &os ) : SymTab::Indexer( false ), os( os ) {}
     28        AlternativePrinter::AlternativePrinter( std::ostream &os ) : os( os ) {}
    2929
    30         void AlternativePrinter::visit( ExprStmt *exprStmt ) {
     30        void AlternativePrinter::postvisit( ExprStmt *exprStmt ) {
    3131                TypeEnvironment env;
    32                 AlternativeFinder finder( *this, env );
     32                AlternativeFinder finder( indexer, env );
    3333                finder.findWithAdjustment( exprStmt->get_expr() );
    3434                int count = 1;
  • src/ResolvExpr/AlternativePrinter.h

    red235b6 r8024bc8  
    1818#include <iostream>          // for ostream
    1919
    20 #include "SymTab/Indexer.h"  // for Indexer
     20#include "Common/PassVisitor.h"
    2121
    2222class ExprStmt;
    2323
    2424namespace ResolvExpr {
    25         class AlternativePrinter final : public SymTab::Indexer {
     25        class AlternativePrinter final : public WithIndexer {
    2626          public:
    2727                AlternativePrinter( std::ostream &os );
    2828
    29                 using SymTab::Indexer::visit;
    30                 virtual void visit( ExprStmt *exprStmt ) override;
     29                void postvisit( ExprStmt *exprStmt );
    3130          private:
    3231                std::ostream &os;
  • src/ResolvExpr/Resolver.cc

    red235b6 r8024bc8  
    2121#include "Alternative.h"                 // for Alternative, AltList
    2222#include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
     23#include "Common/PassVisitor.h"          // for PassVisitor
    2324#include "Common/SemanticError.h"        // for SemanticError
    2425#include "Common/utility.h"              // for ValueGuard, group_iterate
     
    4344
    4445namespace ResolvExpr {
    45         class Resolver final : public SymTab::Indexer {
    46           public:
    47                 Resolver() : SymTab::Indexer( false ) {}
    48                 Resolver( const SymTab:: Indexer & other ) : SymTab::Indexer( other ) {
    49                         if ( const Resolver * res = dynamic_cast< const Resolver * >( &other ) ) {
    50                                 functionReturn = res->functionReturn;
    51                                 currentObject = res->currentObject;
    52                                 inEnumDecl = res->inEnumDecl;
    53                         }
    54                 }
    55 
    56                 typedef SymTab::Indexer Parent;
    57                 using Parent::visit;
    58                 virtual void visit( FunctionDecl *functionDecl ) override;
    59                 virtual void visit( ObjectDecl *functionDecl ) override;
    60                 virtual void visit( TypeDecl *typeDecl ) override;
    61                 virtual void visit( EnumDecl * enumDecl ) override;
    62 
    63                 virtual void visit( ArrayType * at ) override;
    64                 virtual void visit( PointerType * at ) override;
    65 
    66                 virtual void visit( ExprStmt *exprStmt ) override;
    67                 virtual void visit( AsmExpr *asmExpr ) override;
    68                 virtual void visit( AsmStmt *asmStmt ) override;
    69                 virtual void visit( IfStmt *ifStmt ) override;
    70                 virtual void visit( WhileStmt *whileStmt ) override;
    71                 virtual void visit( ForStmt *forStmt ) override;
    72                 virtual void visit( SwitchStmt *switchStmt ) override;
    73                 virtual void visit( CaseStmt *caseStmt ) override;
    74                 virtual void visit( BranchStmt *branchStmt ) override;
    75                 virtual void visit( ReturnStmt *returnStmt ) override;
    76                 virtual void visit( ThrowStmt *throwStmt ) override;
    77                 virtual void visit( CatchStmt *catchStmt ) override;
    78 
    79                 virtual void visit( SingleInit *singleInit ) override;
    80                 virtual void visit( ListInit *listInit ) override;
    81                 virtual void visit( ConstructorInit *ctorInit ) override;
     46        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting {
     47                Resolver() {}
     48                Resolver( const SymTab::Indexer & other ) {
     49                        indexer = other;
     50                }
     51
     52                void previsit( FunctionDecl *functionDecl );
     53                void postvisit( FunctionDecl *functionDecl );
     54                void previsit( ObjectDecl *functionDecl );
     55                void previsit( TypeDecl *typeDecl );
     56                void previsit( EnumDecl * enumDecl );
     57
     58                void previsit( ArrayType * at );
     59                void previsit( PointerType * at );
     60
     61                void previsit( ExprStmt *exprStmt );
     62                void previsit( AsmExpr *asmExpr );
     63                void previsit( AsmStmt *asmStmt );
     64                void previsit( IfStmt *ifStmt );
     65                void previsit( WhileStmt *whileStmt );
     66                void previsit( ForStmt *forStmt );
     67                void previsit( SwitchStmt *switchStmt );
     68                void previsit( CaseStmt *caseStmt );
     69                void previsit( BranchStmt *branchStmt );
     70                void previsit( ReturnStmt *returnStmt );
     71                void previsit( ThrowStmt *throwStmt );
     72                void previsit( CatchStmt *catchStmt );
     73
     74                void previsit( SingleInit *singleInit );
     75                void previsit( ListInit *listInit );
     76                void previsit( ConstructorInit *ctorInit );
    8277          private:
    8378        typedef std::list< Initializer * >::iterator InitIterator;
     
    9691
    9792        void resolve( std::list< Declaration * > translationUnit ) {
    98                 Resolver resolver;
     93                PassVisitor<Resolver> resolver;
    9994                acceptAll( translationUnit, resolver );
    10095        }
    10196
     97        // used in resolveTypeof
    10298        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
    10399                TypeEnvironment env;
    104100                return resolveInVoidContext( expr, indexer, env );
    105101        }
    106 
    107102
    108103        namespace {
     
    190185        }
    191186
    192         void Resolver::visit( ObjectDecl *objectDecl ) {
    193                 Type *new_type = resolveTypeof( objectDecl->get_type(), *this );
     187        void Resolver::previsit( ObjectDecl *objectDecl ) {
     188                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
    194189                objectDecl->set_type( new_type );
    195190                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
     
    198193                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
    199194                // the RHS.
    200                 ValueGuard<CurrentObject> temp( currentObject );
     195                GuardValue( currentObject );
    201196                currentObject = CurrentObject( objectDecl->get_type() );
    202197                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
     
    205200                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    206201                }
    207                 Parent::visit( objectDecl );
    208                 if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
    209                         // delete newly created signed int type
    210                         // delete currentObject.getType();
    211                 }
    212202        }
    213203
     
    216206                if ( type->get_dimension() ) {
    217207                        CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
    218                         Expression *newExpr = findSingleExpression( castExpr, *this );
     208                        Expression *newExpr = findSingleExpression( castExpr, indexer );
    219209                        delete type->get_dimension();
    220210                        type->set_dimension( newExpr );
     
    222212        }
    223213
    224         void Resolver::visit( ArrayType * at ) {
     214        void Resolver::previsit( ArrayType * at ) {
    225215                handlePtrType( at );
    226                 Parent::visit( at );
    227         }
    228 
    229         void Resolver::visit( PointerType * pt ) {
     216        }
     217
     218        void Resolver::previsit( PointerType * pt ) {
    230219                handlePtrType( pt );
    231                 Parent::visit( pt );
    232         }
    233 
    234         void Resolver::visit( TypeDecl *typeDecl ) {
     220        }
     221
     222        void Resolver::previsit( TypeDecl *typeDecl ) {
    235223                if ( typeDecl->get_base() ) {
    236                         Type *new_type = resolveTypeof( typeDecl->get_base(), *this );
     224                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
    237225                        typeDecl->set_base( new_type );
    238226                } // if
    239                 Parent::visit( typeDecl );
    240         }
    241 
    242         void Resolver::visit( FunctionDecl *functionDecl ) {
     227        }
     228
     229        void Resolver::previsit( FunctionDecl *functionDecl ) {
    243230#if 0
    244                 std::cout << "resolver visiting functiondecl ";
    245                 functionDecl->print( std::cout );
    246                 std::cout << std::endl;
     231                std::cerr << "resolver visiting functiondecl ";
     232                functionDecl->print( std::cerr );
     233                std::cerr << std::endl;
    247234#endif
    248                 Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
     235                Type *new_type = resolveTypeof( functionDecl->get_type(), indexer );
    249236                functionDecl->set_type( new_type );
    250                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
     237                GuardValue( functionReturn );
    251238                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
    252                 Parent::visit( functionDecl );
    253 
     239        }
     240
     241
     242        void Resolver::postvisit( FunctionDecl *functionDecl ) {
    254243                // default value expressions have an environment which shouldn't be there and trips up later passes.
    255244                // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently
     
    265254        }
    266255
    267         void Resolver::visit( EnumDecl * enumDecl ) {
     256        void Resolver::previsit( EnumDecl * ) {
    268257                // in case we decide to allow nested enums
    269                 ValueGuard< bool > oldInEnumDecl( inEnumDecl );
     258                GuardValue( inEnumDecl );
    270259                inEnumDecl = true;
    271                 Parent::visit( enumDecl );
    272         }
    273 
    274         void Resolver::visit( ExprStmt *exprStmt ) {
     260        }
     261
     262        void Resolver::previsit( ExprStmt *exprStmt ) {
     263                visit_children = false;
    275264                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
    276                 Expression *newExpr = findVoidExpression( exprStmt->get_expr(), *this );
     265                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
    277266                delete exprStmt->get_expr();
    278267                exprStmt->set_expr( newExpr );
    279268        }
    280269
    281         void Resolver::visit( AsmExpr *asmExpr ) {
    282                 Expression *newExpr = findVoidExpression( asmExpr->get_operand(), *this );
     270        void Resolver::previsit( AsmExpr *asmExpr ) {
     271                visit_children = false;
     272                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
    283273                delete asmExpr->get_operand();
    284274                asmExpr->set_operand( newExpr );
    285275                if ( asmExpr->get_inout() ) {
    286                         newExpr = findVoidExpression( asmExpr->get_inout(), *this );
     276                        newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
    287277                        delete asmExpr->get_inout();
    288278                        asmExpr->set_inout( newExpr );
     
    290280        }
    291281
    292         void Resolver::visit( AsmStmt *asmStmt ) {
    293                 acceptAll( asmStmt->get_input(), *this);
    294                 acceptAll( asmStmt->get_output(), *this);
    295         }
    296 
    297         void Resolver::visit( IfStmt *ifStmt ) {
    298                 Expression *newExpr = findSingleExpression( ifStmt->get_condition(), *this );
     282        void Resolver::previsit( AsmStmt *asmStmt ) {
     283                visit_children = false;
     284                acceptAll( asmStmt->get_input(), *visitor );
     285                acceptAll( asmStmt->get_output(), *visitor );
     286        }
     287
     288        void Resolver::previsit( IfStmt *ifStmt ) {
     289                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
    299290                delete ifStmt->get_condition();
    300291                ifStmt->set_condition( newExpr );
    301                 Parent::visit( ifStmt );
    302         }
    303 
    304         void Resolver::visit( WhileStmt *whileStmt ) {
    305                 Expression *newExpr = findSingleExpression( whileStmt->get_condition(), *this );
     292        }
     293
     294        void Resolver::previsit( WhileStmt *whileStmt ) {
     295                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
    306296                delete whileStmt->get_condition();
    307297                whileStmt->set_condition( newExpr );
    308                 Parent::visit( whileStmt );
    309         }
    310 
    311         void Resolver::visit( ForStmt *forStmt ) {
    312                 Parent::visit( forStmt );
    313 
     298        }
     299
     300        void Resolver::previsit( ForStmt *forStmt ) {
    314301                if ( forStmt->get_condition() ) {
    315                         Expression * newExpr = findSingleExpression( forStmt->get_condition(), *this );
     302                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
    316303                        delete forStmt->get_condition();
    317304                        forStmt->set_condition( newExpr );
     
    319306
    320307                if ( forStmt->get_increment() ) {
    321                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
     308                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
    322309                        delete forStmt->get_increment();
    323310                        forStmt->set_increment( newExpr );
     
    325312        }
    326313
    327         void Resolver::visit( SwitchStmt *switchStmt ) {
    328                 ValueGuard< CurrentObject > oldCurrentObject( currentObject );
     314        void Resolver::previsit( SwitchStmt *switchStmt ) {
     315                GuardValue( currentObject );
    329316                Expression *newExpr;
    330                 newExpr = findIntegralExpression( switchStmt->get_condition(), *this );
     317                newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
    331318                delete switchStmt->get_condition();
    332319                switchStmt->set_condition( newExpr );
    333320
    334321                currentObject = CurrentObject( newExpr->get_result() );
    335                 Parent::visit( switchStmt );
    336         }
    337 
    338         void Resolver::visit( CaseStmt *caseStmt ) {
     322        }
     323
     324        void Resolver::previsit( CaseStmt *caseStmt ) {
    339325                if ( caseStmt->get_condition() ) {
    340326                        std::list< InitAlternative > initAlts = currentObject.getOptions();
    341327                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
    342328                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
    343                         Expression * newExpr = findSingleExpression( castExpr, *this );
     329                        Expression * newExpr = findSingleExpression( castExpr, indexer );
    344330                        castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
    345331                        caseStmt->set_condition( castExpr->get_arg() );
     
    347333                        delete castExpr;
    348334                }
    349                 Parent::visit( caseStmt );
    350         }
    351 
    352         void Resolver::visit( BranchStmt *branchStmt ) {
     335        }
     336
     337        void Resolver::previsit( BranchStmt *branchStmt ) {
     338                visit_children = false;
    353339                // must resolve the argument for a computed goto
    354340                if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
     
    357343                                PointerType pt( Type::Qualifiers(), v.clone() );
    358344                                CastExpr * castExpr = new CastExpr( arg, pt.clone() );
    359                                 Expression * newExpr = findSingleExpression( castExpr, *this ); // find best expression
     345                                Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
    360346                                branchStmt->set_target( newExpr );
    361347                        } // if
     
    363349        }
    364350
    365         void Resolver::visit( ReturnStmt *returnStmt ) {
     351        void Resolver::previsit( ReturnStmt *returnStmt ) {
     352                visit_children = false;
    366353                if ( returnStmt->get_expr() ) {
    367354                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
    368                         Expression *newExpr = findSingleExpression( castExpr, *this );
     355                        Expression *newExpr = findSingleExpression( castExpr, indexer );
    369356                        delete castExpr;
    370357                        returnStmt->set_expr( newExpr );
     
    372359        }
    373360
    374         void Resolver::visit( ThrowStmt *throwStmt ) {
     361        void Resolver::previsit( ThrowStmt *throwStmt ) {
     362                visit_children = false;
    375363                // TODO: Replace *exception type with &exception type.
    376364                if ( throwStmt->get_expr() ) {
    377365                        StructDecl * exception_decl =
    378                                 lookupStruct( "__cfaehm__base_exception_t" );
     366                                indexer.lookupStruct( "__cfaehm__base_exception_t" );
    379367                        assert( exception_decl );
    380368                        Expression * wrapped = new CastExpr(
     
    388376                                        )
    389377                                );
    390                         Expression * newExpr = findSingleExpression( wrapped, *this );
     378                        Expression * newExpr = findSingleExpression( wrapped, indexer );
    391379                        throwStmt->set_expr( newExpr );
    392380                }
    393381        }
    394382
    395         void Resolver::visit( CatchStmt *catchStmt ) {
    396                 // inline Indexer::visit so that the exception variable is still in-scope for
    397                 // findSingleExpression() below
    398                 Parent::enterScope();
    399                 Visitor::visit( catchStmt );
    400 
     383        void Resolver::previsit( CatchStmt *catchStmt ) {
    401384                if ( catchStmt->get_cond() ) {
    402385                        Expression * wrapped = new CastExpr(
     
    404387                                new BasicType( noQualifiers, BasicType::Bool )
    405388                                );
    406                         catchStmt->set_cond( findSingleExpression( wrapped, *this ) );
    407                 }
    408 
    409                 Parent::leaveScope();
     389                        catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
     390                }
    410391        }
    411392
     
    419400        }
    420401
    421         void Resolver::visit( SingleInit *singleInit ) {
     402        void Resolver::previsit( SingleInit *singleInit ) {
     403                visit_children = false;
    422404                // resolve initialization using the possibilities as determined by the currentObject cursor
    423405                UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
    424                 Expression * newExpr = findSingleExpression( untyped, *this );
     406                Expression * newExpr = findSingleExpression( untyped, indexer );
    425407                InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
    426408
     
    461443        }
    462444
    463         void Resolver::visit( ListInit * listInit ) {
     445        void Resolver::previsit( ListInit * listInit ) {
     446                visit_children = false;
    464447                // move cursor into brace-enclosed initializer-list
    465448                currentObject.enterListInit();
     
    472455                        Initializer * init = std::get<1>(p);
    473456                        newDesignations.push_back( currentObject.findNext( des ) );
    474                         init->accept( *this );
     457                        init->accept( *visitor );
    475458                }
    476459                // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
     
    501484                delete ctorInit->get_dtor();
    502485                ctorInit->set_dtor( NULL );
    503                 maybeAccept( ctorInit->get_init(), *this );
     486                maybeAccept( ctorInit->get_init(), *visitor );
    504487        }
    505488
     
    507490        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
    508491                assert( ctorInit );
    509                 Resolver resolver( indexer );
     492                PassVisitor<Resolver> resolver( indexer );
    510493                ctorInit->accept( resolver );
    511494        }
     
    513496        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
    514497                assert( stmtExpr );
    515                 Resolver resolver( indexer );
     498                PassVisitor<Resolver> resolver( indexer );
    516499                stmtExpr->accept( resolver );
    517500        }
    518501
    519         void Resolver::visit( ConstructorInit *ctorInit ) {
     502        void Resolver::previsit( ConstructorInit *ctorInit ) {
     503                visit_children = false;
    520504                // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
    521                 maybeAccept( ctorInit->get_ctor(), *this );
    522                 maybeAccept( ctorInit->get_dtor(), *this );
     505                maybeAccept( ctorInit->get_ctor(), *visitor );
     506                maybeAccept( ctorInit->get_dtor(), *visitor );
    523507
    524508                // found a constructor - can get rid of C-style initializer
  • src/SymTab/Indexer.cc

    red235b6 r8024bc8  
    3737#include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
    3838
    39 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
     39#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
    4040
    4141namespace SymTab {
     
    230230
    231231                return *this;
    232         }
    233 
    234         void Indexer::visit( ObjectDecl *objectDecl ) {
    235                 enterScope();
    236                 maybeAccept( objectDecl->get_type(), *this );
    237                 leaveScope();
    238                 maybeAccept( objectDecl->get_init(), *this );
    239                 maybeAccept( objectDecl->get_bitfieldWidth(), *this );
    240                 if ( objectDecl->get_name() != "" ) {
    241                         debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
    242                         addId( objectDecl );
    243                 } // if
    244         }
    245 
    246         void Indexer::visit( FunctionDecl *functionDecl ) {
    247                 if ( functionDecl->get_name() == "" ) return;
    248                 debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
    249                 addId( functionDecl );
    250                 enterScope();
    251                 maybeAccept( functionDecl->get_functionType(), *this );
    252                 maybeAccept( functionDecl->get_statements(), *this );
    253                 leaveScope();
    254         }
    255 
    256 
    257 // A NOTE ON THE ORDER OF TRAVERSAL
    258 //
    259 // Types and typedefs have their base types visited before they are added to the type table.  This is ok, since there is
    260 // no such thing as a recursive type or typedef.
    261 //
    262 //             typedef struct { T *x; } T; // never allowed
    263 //
    264 // for structs/unions, it is possible to have recursion, so the decl should be added as if it's incomplete to begin, the
    265 // members are traversed, and then the complete type should be added (assuming the type is completed by this particular
    266 // declaration).
    267 //
    268 //             struct T { struct T *x; }; // allowed
    269 //
    270 // It is important to add the complete type to the symbol table *after* the members/base has been traversed, since that
    271 // traversal may modify the definition of the type and these modifications should be visible when the symbol table is
    272 // queried later in this pass.
    273 //
    274 // TODO: figure out whether recursive contexts are sensible/possible/reasonable.
    275 
    276 
    277         void Indexer::visit( TypeDecl *typeDecl ) {
    278                 // see A NOTE ON THE ORDER OF TRAVERSAL, above
    279                 // note that assertions come after the type is added to the symtab, since they are not part of the type proper
    280                 // and may depend on the type itself
    281                 enterScope();
    282                 acceptAll( typeDecl->get_parameters(), *this );
    283                 maybeAccept( typeDecl->get_base(), *this );
    284                 leaveScope();
    285                 debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
    286                 addType( typeDecl );
    287                 acceptAll( typeDecl->get_assertions(), *this );
    288                 acceptNewScope( typeDecl->get_init(), *this );
    289         }
    290 
    291         void Indexer::visit( TypedefDecl *typeDecl ) {
    292                 enterScope();
    293                 acceptAll( typeDecl->get_parameters(), *this );
    294                 maybeAccept( typeDecl->get_base(), *this );
    295                 leaveScope();
    296                 debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
    297                 addType( typeDecl );
    298         }
    299 
    300         void Indexer::visit( StructDecl *aggregateDecl ) {
    301                 // make up a forward declaration and add it before processing the members
    302                 // needs to be on the heap because addStruct saves the pointer
    303                 StructDecl &fwdDecl = *new StructDecl( aggregateDecl->get_name() );
    304                 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
    305                 debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
    306                 addStruct( &fwdDecl );
    307 
    308                 enterScope();
    309                 acceptAll( aggregateDecl->get_parameters(), *this );
    310                 acceptAll( aggregateDecl->get_members(), *this );
    311                 leaveScope();
    312 
    313                 debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
    314                 // this addition replaces the forward declaration
    315                 addStruct( aggregateDecl );
    316         }
    317 
    318         void Indexer::visit( UnionDecl *aggregateDecl ) {
    319                 // make up a forward declaration and add it before processing the members
    320                 UnionDecl fwdDecl( aggregateDecl->get_name() );
    321                 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
    322                 debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
    323                 addUnion( &fwdDecl );
    324 
    325                 enterScope();
    326                 acceptAll( aggregateDecl->get_parameters(), *this );
    327                 acceptAll( aggregateDecl->get_members(), *this );
    328                 leaveScope();
    329 
    330                 debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
    331                 addUnion( aggregateDecl );
    332         }
    333 
    334         void Indexer::visit( EnumDecl *aggregateDecl ) {
    335                 debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
    336                 addEnum( aggregateDecl );
    337                 // unlike structs, contexts, and unions, enums inject their members into the global scope
    338                 acceptAll( aggregateDecl->get_members(), *this );
    339         }
    340 
    341         void Indexer::visit( TraitDecl *aggregateDecl ) {
    342                 enterScope();
    343                 acceptAll( aggregateDecl->get_parameters(), *this );
    344                 acceptAll( aggregateDecl->get_members(), *this );
    345                 leaveScope();
    346 
    347                 debugPrint( "Adding trait " << aggregateDecl->get_name() << std::endl );
    348                 addTrait( aggregateDecl );
    349         }
    350 
    351         void Indexer::visit( CompoundStmt *compoundStmt ) {
    352                 enterScope();
    353                 acceptAll( compoundStmt->get_kids(), *this );
    354                 leaveScope();
    355         }
    356 
    357         void Indexer::visit( IfStmt *ifStmt ) {
    358             // for statements introduce a level of scope
    359             enterScope();
    360             Visitor::visit( ifStmt );
    361             leaveScope();
    362         }
    363 
    364         void Indexer::visit( ForStmt *forStmt ) {
    365             // for statements introduce a level of scope
    366             enterScope();
    367             Visitor::visit( forStmt );
    368             leaveScope();
    369         }
    370 
    371         void Indexer::visit( CatchStmt *catchStmt ) {
    372                 // catch statements introduce a level of scope (for the caught exception)
    373                 enterScope();
    374                 Visitor::visit( catchStmt );
    375                 leaveScope();
    376         }
    377 
    378         void Indexer::visit( ApplicationExpr *applicationExpr ) {
    379                 acceptNewScope( applicationExpr->get_result(), *this );
    380                 maybeAccept( applicationExpr->get_function(), *this );
    381                 acceptAll( applicationExpr->get_args(), *this );
    382         }
    383 
    384         void Indexer::visit( UntypedExpr *untypedExpr ) {
    385                 acceptNewScope( untypedExpr->get_result(), *this );
    386                 acceptAll( untypedExpr->get_args(), *this );
    387         }
    388 
    389         void Indexer::visit( NameExpr *nameExpr ) {
    390                 acceptNewScope( nameExpr->get_result(), *this );
    391         }
    392 
    393         void Indexer::visit( AddressExpr *addressExpr ) {
    394                 acceptNewScope( addressExpr->get_result(), *this );
    395                 maybeAccept( addressExpr->get_arg(), *this );
    396         }
    397 
    398         void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
    399                 acceptNewScope( labAddressExpr->get_result(), *this );
    400         }
    401 
    402         void Indexer::visit( CastExpr *castExpr ) {
    403                 acceptNewScope( castExpr->get_result(), *this );
    404                 maybeAccept( castExpr->get_arg(), *this );
    405         }
    406 
    407         void Indexer::visit( UntypedMemberExpr *memberExpr ) {
    408                 acceptNewScope( memberExpr->get_result(), *this );
    409                 maybeAccept( memberExpr->get_aggregate(), *this );
    410         }
    411 
    412         void Indexer::visit( MemberExpr *memberExpr ) {
    413                 acceptNewScope( memberExpr->get_result(), *this );
    414                 maybeAccept( memberExpr->get_aggregate(), *this );
    415         }
    416 
    417         void Indexer::visit( VariableExpr *variableExpr ) {
    418                 acceptNewScope( variableExpr->get_result(), *this );
    419         }
    420 
    421         void Indexer::visit( ConstantExpr *constantExpr ) {
    422                 acceptNewScope( constantExpr->get_result(), *this );
    423                 maybeAccept( constantExpr->get_constant(), *this );
    424         }
    425 
    426         void Indexer::visit( SizeofExpr *sizeofExpr ) {
    427                 acceptNewScope( sizeofExpr->get_result(), *this );
    428                 if ( sizeofExpr->get_isType() ) {
    429                         maybeAccept( sizeofExpr->get_type(), *this );
    430                 } else {
    431                         maybeAccept( sizeofExpr->get_expr(), *this );
    432                 }
    433         }
    434 
    435         void Indexer::visit( AlignofExpr *alignofExpr ) {
    436                 acceptNewScope( alignofExpr->get_result(), *this );
    437                 if ( alignofExpr->get_isType() ) {
    438                         maybeAccept( alignofExpr->get_type(), *this );
    439                 } else {
    440                         maybeAccept( alignofExpr->get_expr(), *this );
    441                 }
    442         }
    443 
    444         void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
    445                 acceptNewScope( offsetofExpr->get_result(), *this );
    446                 maybeAccept( offsetofExpr->get_type(), *this );
    447         }
    448 
    449         void Indexer::visit( OffsetofExpr *offsetofExpr ) {
    450                 acceptNewScope( offsetofExpr->get_result(), *this );
    451                 maybeAccept( offsetofExpr->get_type(), *this );
    452                 maybeAccept( offsetofExpr->get_member(), *this );
    453         }
    454 
    455         void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
    456                 acceptNewScope( offsetPackExpr->get_result(), *this );
    457                 maybeAccept( offsetPackExpr->get_type(), *this );
    458         }
    459 
    460         void Indexer::visit( AttrExpr *attrExpr ) {
    461                 acceptNewScope( attrExpr->get_result(), *this );
    462                 if ( attrExpr->get_isType() ) {
    463                         maybeAccept( attrExpr->get_type(), *this );
    464                 } else {
    465                         maybeAccept( attrExpr->get_expr(), *this );
    466                 }
    467         }
    468 
    469         void Indexer::visit( LogicalExpr *logicalExpr ) {
    470                 acceptNewScope( logicalExpr->get_result(), *this );
    471                 maybeAccept( logicalExpr->get_arg1(), *this );
    472                 maybeAccept( logicalExpr->get_arg2(), *this );
    473         }
    474 
    475         void Indexer::visit( ConditionalExpr *conditionalExpr ) {
    476                 acceptNewScope( conditionalExpr->get_result(), *this );
    477                 maybeAccept( conditionalExpr->get_arg1(), *this );
    478                 maybeAccept( conditionalExpr->get_arg2(), *this );
    479                 maybeAccept( conditionalExpr->get_arg3(), *this );
    480         }
    481 
    482         void Indexer::visit( CommaExpr *commaExpr ) {
    483                 acceptNewScope( commaExpr->get_result(), *this );
    484                 maybeAccept( commaExpr->get_arg1(), *this );
    485                 maybeAccept( commaExpr->get_arg2(), *this );
    486         }
    487 
    488         void Indexer::visit( TypeExpr *typeExpr ) {
    489                 acceptNewScope( typeExpr->get_result(), *this );
    490                 maybeAccept( typeExpr->get_type(), *this );
    491         }
    492 
    493         void Indexer::visit( AsmExpr *asmExpr ) {
    494                 maybeAccept( asmExpr->get_inout(), *this );
    495                 maybeAccept( asmExpr->get_constraint(), *this );
    496                 maybeAccept( asmExpr->get_operand(), *this );
    497         }
    498 
    499         void Indexer::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
    500                 acceptNewScope( impCpCtorExpr->get_result(), *this );
    501                 maybeAccept( impCpCtorExpr->get_callExpr(), *this );
    502                 acceptAll( impCpCtorExpr->get_tempDecls(), *this );
    503                 acceptAll( impCpCtorExpr->get_returnDecls(), *this );
    504                 acceptAll( impCpCtorExpr->get_dtors(), *this );
    505         }
    506 
    507         void Indexer::visit( ConstructorExpr * ctorExpr ) {
    508                 acceptNewScope( ctorExpr->get_result(), *this );
    509                 maybeAccept( ctorExpr->get_callExpr(), *this );
    510         }
    511 
    512         void Indexer::visit( CompoundLiteralExpr *compLitExpr ) {
    513                 acceptNewScope( compLitExpr->get_result(), *this );
    514                 maybeAccept( compLitExpr->get_initializer(), *this );
    515         }
    516 
    517         void Indexer::visit( RangeExpr *rangeExpr ) {
    518                 maybeAccept( rangeExpr->get_low(), *this );
    519                 maybeAccept( rangeExpr->get_high(), *this );
    520         }
    521 
    522         void Indexer::visit( UntypedTupleExpr *tupleExpr ) {
    523                 acceptNewScope( tupleExpr->get_result(), *this );
    524                 acceptAll( tupleExpr->get_exprs(), *this );
    525         }
    526 
    527         void Indexer::visit( TupleExpr *tupleExpr ) {
    528                 acceptNewScope( tupleExpr->get_result(), *this );
    529                 acceptAll( tupleExpr->get_exprs(), *this );
    530         }
    531 
    532         void Indexer::visit( TupleIndexExpr *tupleExpr ) {
    533                 acceptNewScope( tupleExpr->get_result(), *this );
    534                 maybeAccept( tupleExpr->get_tuple(), *this );
    535         }
    536 
    537         void Indexer::visit( TupleAssignExpr *tupleExpr ) {
    538                 acceptNewScope( tupleExpr->get_result(), *this );
    539                 maybeAccept( tupleExpr->get_stmtExpr(), *this );
    540         }
    541 
    542         void Indexer::visit( StmtExpr *stmtExpr ) {
    543                 acceptNewScope( stmtExpr->get_result(), *this );
    544                 maybeAccept( stmtExpr->get_statements(), *this );
    545                 acceptAll( stmtExpr->get_returnDecls(), *this );
    546                 acceptAll( stmtExpr->get_dtors(), *this );
    547         }
    548 
    549         void Indexer::visit( UniqueExpr *uniqueExpr ) {
    550                 acceptNewScope( uniqueExpr->get_result(), *this );
    551                 maybeAccept( uniqueExpr->get_expr(), *this );
    552         }
    553 
    554 
    555         void Indexer::visit( TraitInstType *traitInst ) {
    556                 acceptAll( traitInst->get_parameters(), *this );
    557         }
    558 
    559         void Indexer::visit( StructInstType *structInst ) {
    560                 if ( ! lookupStruct( structInst->get_name() ) ) {
    561                         debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
    562                         addStruct( structInst->get_name() );
    563                 }
    564                 enterScope();
    565                 acceptAll( structInst->get_parameters(), *this );
    566                 leaveScope();
    567         }
    568 
    569         void Indexer::visit( UnionInstType *unionInst ) {
    570                 if ( ! lookupUnion( unionInst->get_name() ) ) {
    571                         debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
    572                         addUnion( unionInst->get_name() );
    573                 }
    574                 enterScope();
    575                 acceptAll( unionInst->get_parameters(), *this );
    576                 leaveScope();
    577232        }
    578233
     
    762417
    763418        void Indexer::addId( DeclarationWithType *decl ) {
     419                debugPrint( "Adding Id " << decl->name << std::endl );
    764420                makeWritable();
    765421
     
    811467
    812468        void Indexer::addType( NamedTypeDecl *decl ) {
     469                debugPrint( "Adding type " << decl->name << std::endl );
    813470                makeWritable();
    814471
     
    838495
    839496        void Indexer::addStruct( const std::string &id ) {
     497                debugPrint( "Adding fwd decl for struct " << id << std::endl );
    840498                addStruct( new StructDecl( id ) );
    841499        }
    842500
    843501        void Indexer::addStruct( StructDecl *decl ) {
     502                debugPrint( "Adding struct " << decl->name << std::endl );
    844503                makeWritable();
    845504
     
    860519
    861520        void Indexer::addEnum( EnumDecl *decl ) {
     521                debugPrint( "Adding enum " << decl->name << std::endl );
    862522                makeWritable();
    863523
     
    878538
    879539        void Indexer::addUnion( const std::string &id ) {
     540                debugPrint( "Adding fwd decl for union " << id << std::endl );
    880541                addUnion( new UnionDecl( id ) );
    881542        }
    882543
    883544        void Indexer::addUnion( UnionDecl *decl ) {
     545                debugPrint( "Adding union " << decl->name << std::endl );
    884546                makeWritable();
    885547
     
    900562
    901563        void Indexer::addTrait( TraitDecl *decl ) {
     564                debugPrint( "Adding trait " << decl->name << std::endl );
    902565                makeWritable();
    903566
  • src/SymTab/Indexer.h

    red235b6 r8024bc8  
    2424
    2525namespace SymTab {
    26         class Indexer : public Visitor {
     26        class Indexer {
    2727          public:
    2828                explicit Indexer( bool useDebug = false );
     
    3333                Indexer& operator= ( const Indexer &that );
    3434                Indexer& operator= ( Indexer &&that );
    35 
    36                 using Visitor::visit;
    37                 virtual void visit( ObjectDecl *objectDecl );
    38                 virtual void visit( FunctionDecl *functionDecl );
    39                 virtual void visit( TypeDecl *typeDecl );
    40                 virtual void visit( TypedefDecl *typeDecl );
    41                 virtual void visit( StructDecl *aggregateDecl );
    42                 virtual void visit( UnionDecl *aggregateDecl );
    43                 virtual void visit( EnumDecl *aggregateDecl );
    44                 virtual void visit( TraitDecl *aggregateDecl );
    45 
    46                 virtual void visit( CompoundStmt *compoundStmt );
    47                 virtual void visit( IfStmt *ifStmt );
    48                 virtual void visit( ForStmt *forStmt );
    49                 virtual void visit( CatchStmt *catchStmt );
    50 
    51                 virtual void visit( ApplicationExpr *applicationExpr );
    52                 virtual void visit( UntypedExpr *untypedExpr );
    53                 virtual void visit( NameExpr *nameExpr );
    54                 virtual void visit( CastExpr *castExpr );
    55                 virtual void visit( AddressExpr *addressExpr );
    56                 virtual void visit( LabelAddressExpr *labAddressExpr );
    57                 virtual void visit( UntypedMemberExpr *memberExpr );
    58                 virtual void visit( MemberExpr *memberExpr );
    59                 virtual void visit( VariableExpr *variableExpr );
    60                 virtual void visit( ConstantExpr *constantExpr );
    61                 virtual void visit( SizeofExpr *sizeofExpr );
    62                 virtual void visit( AlignofExpr *alignofExpr );
    63                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
    64                 virtual void visit( OffsetofExpr *offsetofExpr );
    65                 virtual void visit( OffsetPackExpr *offsetPackExpr );
    66                 virtual void visit( AttrExpr *attrExpr );
    67                 virtual void visit( LogicalExpr *logicalExpr );
    68                 virtual void visit( ConditionalExpr *conditionalExpr );
    69                 virtual void visit( CommaExpr *commaExpr );
    70                 virtual void visit( TypeExpr *typeExpr );
    71                 virtual void visit( AsmExpr *asmExpr );
    72                 virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
    73                 virtual void visit( ConstructorExpr * ctorExpr );
    74                 virtual void visit( CompoundLiteralExpr *compLitExpr );
    75                 virtual void visit( RangeExpr *rangeExpr );
    76                 virtual void visit( UntypedTupleExpr *tupleExpr );
    77                 virtual void visit( TupleExpr *tupleExpr );
    78                 virtual void visit( TupleIndexExpr *tupleExpr );
    79                 virtual void visit( TupleAssignExpr *tupleExpr );
    80                 virtual void visit( StmtExpr * stmtExpr );
    81                 virtual void visit( UniqueExpr * uniqueExpr );
    82 
    83                 virtual void visit( TraitInstType *contextInst );
    84                 virtual void visit( StructInstType *contextInst );
    85                 virtual void visit( UnionInstType *contextInst );
    8635
    8736                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
     
    10453
    10554                void print( std::ostream &os, int indent = 0 ) const;
    106           private:
     55
    10756                /// looks up a specific mangled ID at the given scope
    10857                DeclarationWithType *lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
     
    12776                void addTrait( TraitDecl *decl );
    12877
     78          private:
    12979                struct Impl;
    13080
  • src/SymTab/Validate.cc

    red235b6 r8024bc8  
    123123
    124124        /// Associates forward declarations of aggregates with their definitions
    125         class LinkReferenceToTypes final : public Indexer {
    126                 typedef Indexer Parent;
    127           public:
    128                 LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
    129                 using Parent::visit;
    130                 void visit( TypeInstType *typeInst ) final;
    131 
    132                 void visit( EnumInstType *enumInst ) final;
    133                 void visit( StructInstType *structInst ) final;
    134                 void visit( UnionInstType *unionInst ) final;
    135                 void visit( TraitInstType *traitInst ) final;
    136 
    137                 void visit( EnumDecl *enumDecl ) final;
    138                 void visit( StructDecl *structDecl ) final;
    139                 void visit( UnionDecl *unionDecl ) final;
    140                 void visit( TraitDecl * traitDecl ) final;
     125        struct LinkReferenceToTypes final : public WithIndexer {
     126                LinkReferenceToTypes( const Indexer *indexer );
     127                void postvisit( TypeInstType *typeInst );
     128
     129                void postvisit( EnumInstType *enumInst );
     130                void postvisit( StructInstType *structInst );
     131                void postvisit( UnionInstType *unionInst );
     132                void postvisit( TraitInstType *traitInst );
     133
     134                void postvisit( EnumDecl *enumDecl );
     135                void postvisit( StructDecl *structDecl );
     136                void postvisit( UnionDecl *unionDecl );
     137                void postvisit( TraitDecl * traitDecl );
    141138
    142139          private:
    143                 const Indexer *indexer;
     140                const Indexer *local_indexer;
    144141
    145142                typedef std::map< std::string, std::list< EnumInstType * > > ForwardEnumsType;
     
    152149
    153150        /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
    154         class ForallPointerDecay final : public Indexer {
    155                 typedef Indexer Parent;
    156           public:
    157                 using Parent::visit;
    158                 ForallPointerDecay( const Indexer *indexer );
    159 
    160                 virtual void visit( ObjectDecl *object ) override;
    161                 virtual void visit( FunctionDecl *func ) override;
    162 
    163                 const Indexer *indexer;
     151        struct ForallPointerDecay final {
     152                void previsit( ObjectDecl *object );
     153                void previsit( FunctionDecl *func );
    164154        };
    165155
     
    263253        };
    264254
    265         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
     255        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
    266256                PassVisitor<EnumAndPointerDecay> epc;
    267                 LinkReferenceToTypes lrt( doDebug, 0 );
    268                 ForallPointerDecay fpd( 0 );
     257                PassVisitor<LinkReferenceToTypes> lrt( nullptr );
     258                PassVisitor<ForallPointerDecay> fpd;
    269259                PassVisitor<CompoundLiteral> compoundliteral;
    270260                PassVisitor<ValidateGenericParameters> genericParams;
     
    293283        void validateType( Type *type, const Indexer *indexer ) {
    294284                PassVisitor<EnumAndPointerDecay> epc;
    295                 LinkReferenceToTypes lrt( false, indexer );
    296                 ForallPointerDecay fpd( indexer );
     285                PassVisitor<LinkReferenceToTypes> lrt( indexer );
     286                PassVisitor<ForallPointerDecay> fpd;
    297287                type->accept( epc );
    298288                type->accept( lrt );
     
    408398        }
    409399
    410         LinkReferenceToTypes::LinkReferenceToTypes( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
     400        LinkReferenceToTypes::LinkReferenceToTypes( const Indexer *other_indexer ) {
    411401                if ( other_indexer ) {
    412                         indexer = other_indexer;
     402                        local_indexer = other_indexer;
    413403                } else {
    414                         indexer = this;
    415                 } // if
    416         }
    417 
    418         void LinkReferenceToTypes::visit( EnumInstType *enumInst ) {
    419                 Parent::visit( enumInst );
    420                 EnumDecl *st = indexer->lookupEnum( enumInst->get_name() );
     404                        local_indexer = &indexer;
     405                } // if
     406        }
     407
     408        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
     409                EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
    421410                // it's not a semantic error if the enum is not found, just an implicit forward declaration
    422411                if ( st ) {
     
    430419        }
    431420
    432         void LinkReferenceToTypes::visit( StructInstType *structInst ) {
    433                 Parent::visit( structInst );
    434                 StructDecl *st = indexer->lookupStruct( structInst->get_name() );
     421        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
     422                StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
    435423                // it's not a semantic error if the struct is not found, just an implicit forward declaration
    436424                if ( st ) {
     
    444432        }
    445433
    446         void LinkReferenceToTypes::visit( UnionInstType *unionInst ) {
    447                 Parent::visit( unionInst );
    448                 UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
     434        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
     435                UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
    449436                // it's not a semantic error if the union is not found, just an implicit forward declaration
    450437                if ( un ) {
     
    499486        }
    500487
    501         void LinkReferenceToTypes::visit( TraitDecl * traitDecl ) {
    502                 Parent::visit( traitDecl );
    503 
     488        void LinkReferenceToTypes::postvisit( TraitDecl * traitDecl ) {
    504489                if ( traitDecl->name == "sized" ) {
    505490                        // "sized" is a special trait - flick the sized status on for the type variable
     
    523508        }
    524509
    525         void LinkReferenceToTypes::visit( TraitInstType * traitInst ) {
    526                 Parent::visit( traitInst );
     510        void LinkReferenceToTypes::postvisit( TraitInstType * traitInst ) {
    527511                // handle other traits
    528                 TraitDecl *traitDecl = indexer->lookupTrait( traitInst->name );
     512                TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
    529513                if ( ! traitDecl ) {
    530514                        throw SemanticError( "use of undeclared trait " + traitInst->name );
     
    547531        }
    548532
    549         void LinkReferenceToTypes::visit( EnumDecl *enumDecl ) {
     533        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
    550534                // visit enum members first so that the types of self-referencing members are updated properly
    551                 Parent::visit( enumDecl );
    552535                if ( ! enumDecl->get_members().empty() ) {
    553536                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
     
    561544        }
    562545
    563         void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
     546        void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
    564547                // visit struct members first so that the types of self-referencing members are updated properly
    565                 // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and and their defaults)
    566                 Parent::visit( structDecl );
     548                // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
    567549                if ( ! structDecl->get_members().empty() ) {
    568550                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
     
    576558        }
    577559
    578         void LinkReferenceToTypes::visit( UnionDecl *unionDecl ) {
    579                 Parent::visit( unionDecl );
     560        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
    580561                if ( ! unionDecl->get_members().empty() ) {
    581562                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
     
    589570        }
    590571
    591         void LinkReferenceToTypes::visit( TypeInstType *typeInst ) {
    592                 if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
     572        void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
     573                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
    593574                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
    594575                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
    595576                        } // if
    596                 } // if
    597         }
    598 
    599         ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) :  Indexer( false ) {
    600                 if ( other_indexer ) {
    601                         indexer = other_indexer;
    602                 } else {
    603                         indexer = this;
    604577                } // if
    605578        }
     
    633606        }
    634607
    635         void ForallPointerDecay::visit( ObjectDecl *object ) {
     608        void ForallPointerDecay::previsit( ObjectDecl *object ) {
    636609                forallFixer( object->get_type() );
    637610                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
    638611                        forallFixer( pointer->get_base() );
    639612                } // if
    640                 Parent::visit( object );
    641613                object->fixUniqueId();
    642614        }
    643615
    644         void ForallPointerDecay::visit( FunctionDecl *func ) {
     616        void ForallPointerDecay::previsit( FunctionDecl *func ) {
    645617                forallFixer( func->get_type() );
    646                 Parent::visit( func );
    647618                func->fixUniqueId();
    648619        }
  • src/libcfa/iostream

    red235b6 r8024bc8  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Sep 11 09:17:07 2017
    13 // Update Count     : 137
     12// Last Modified On : Wed Sep 13 12:53:46 2017
     13// Update Count     : 138
    1414//
    1515
    1616#pragma once
    1717
    18 #include <uchar.h>
    19 #include <wchar.h>
    2018#include "iterator"
    2119
  • src/main.cc

    red235b6 r8024bc8  
    3535#include "CodeTools/DeclStats.h"            // for printDeclStats
    3636#include "CodeTools/TrackLoc.h"             // for fillLocations
     37#include "Common/PassVisitor.h"
    3738#include "Common/CompilerError.h"           // for CompilerError
    3839#include "Common/SemanticError.h"           // for SemanticError
     
    250251
    251252                if ( expraltp ) {
    252                         ResolvExpr::AlternativePrinter printer( cout );
     253                        PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
    253254                        acceptAll( translationUnit, printer );
    254255                        return 0;
  • src/prelude/extras.c

    red235b6 r8024bc8  
    1 #include <stddef.h>
    2 #include <stdlib.h>
    3 #include <stdio.h>
     1#include <stddef.h>                                     // size_t, ptrdiff_t
     2#include <uchar.h>                                      // char16_t, char32_t
     3#include <wchar.h>                                      // wchar_t
     4#include <stdlib.h>                                     // malloc, free, exit, atexit, abort
     5#include <stdio.h>                                      // printf
  • src/prelude/extras.regx

    red235b6 r8024bc8  
    11typedef.* size_t;
    22typedef.* ptrdiff_t;
     3typedef.* char16_t;
     4typedef.* char32_t;
     5typedef.* wchar_t;
     6extern.*\*malloc\(.*\).*
     7extern.* free\(.*\).*
     8extern.* exit\(.*\).*
     9extern.* atexit\(.*\).*
    310extern.* abort\(.*\).*
    4 extern.* atexit\(.*\).*
    5 extern.* exit\(.*\).*
    6 extern.* free\(.*\).*
    7 extern.*\*malloc\(.*\).*
    811extern.* printf\(.*\).*
  • src/tests/.expect/32/literals.txt

    red235b6 r8024bc8  
    55__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
    66extern signed int printf(const char *__restrict __format, ...);
    7 union __anonymous0 {
    8     unsigned int __wch;
    9     char __wchb[((unsigned int )4)];
    10 };
    11 static inline void ___constructor__F_R13u__anonymous0_autogen___1(__attribute__ ((unused)) union __anonymous0 *___dst__R13u__anonymous0_1){
    12 }
    13 static inline void ___constructor__F_R13u__anonymous013u__anonymous0_autogen___1(union __anonymous0 *___dst__R13u__anonymous0_1, union __anonymous0 ___src__13u__anonymous0_1){
    14     ((void)__builtin_memcpy(((void *)___dst__R13u__anonymous0_1), ((const void *)(&___src__13u__anonymous0_1)), sizeof(union __anonymous0 )));
    15 }
    16 static inline void ___destructor__F_R13u__anonymous0_autogen___1(__attribute__ ((unused)) union __anonymous0 *___dst__R13u__anonymous0_1){
    17 }
    18 static inline union __anonymous0 ___operator_assign__F13u__anonymous0_R13u__anonymous013u__anonymous0_autogen___1(union __anonymous0 *___dst__R13u__anonymous0_1, union __anonymous0 ___src__13u__anonymous0_1){
    19     union __anonymous0 ___ret__13u__anonymous0_1;
    20     ((void)__builtin_memcpy(((void *)___dst__R13u__anonymous0_1), ((const void *)(&___src__13u__anonymous0_1)), sizeof(union __anonymous0 )));
    21     ((void)___constructor__F_R13u__anonymous013u__anonymous0_autogen___1((&___ret__13u__anonymous0_1), ___src__13u__anonymous0_1));
    22     return ((union __anonymous0 )___ret__13u__anonymous0_1);
    23 }
    24 static inline void ___constructor__F_R13u__anonymous0Ui_autogen___1(__attribute__ ((unused)) union __anonymous0 *___dst__R13u__anonymous0_1, unsigned int __src__Ui_1){
    25     ((void)__builtin_memcpy(((void *)___dst__R13u__anonymous0_1), ((const void *)(&__src__Ui_1)), sizeof(unsigned int )));
    26 }
    27 struct __anonymous1 {
    28     signed int __count;
    29     union __anonymous0 __value;
    30 };
    31 struct __anonymous1;
    32 struct __anonymous1;
    33 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int mbrtoc16(unsigned short int *__restrict __pc16, const char *__restrict __s, unsigned int __n, struct __anonymous1 *__restrict __p);
    34 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int c16rtomb(char *__restrict __s, unsigned short int __c16, struct __anonymous1 *__restrict __ps);
    35 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int mbrtoc32(unsigned int *__restrict __pc32, const char *__restrict __s, unsigned int __n, struct __anonymous1 *__restrict __p);
    36 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int c32rtomb(char *__restrict __s, unsigned int __c32, struct __anonymous1 *__restrict __ps);
    37 struct _IO_FILE;
    38 struct _IO_FILE;
    39 struct _IO_FILE;
    40 struct tm;
    41 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed long int *wcscpy(signed long int *__restrict __dest, const signed long int *__restrict __src);
    42 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed long int *wcsncpy(signed long int *__restrict __dest, const signed long int *__restrict __src, unsigned int __n);
    43 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed long int *wcscat(signed long int *__restrict __dest, const signed long int *__restrict __src);
    44 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed long int *wcsncat(signed long int *__restrict __dest, const signed long int *__restrict __src, unsigned int __n);
    45 __attribute__ ((__nothrow__,__leaf__,__pure__,__nonnull__(1, 2))) extern signed int wcscmp(const signed long int *__s1, const signed long int *__s2);
    46 __attribute__ ((__nothrow__,__leaf__,__pure__,__nonnull__(1, 2))) extern signed int wcsncmp(const signed long int *__s1, const signed long int *__s2, unsigned int __n);
    47 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscasecmp(const signed long int *__s1, const signed long int *__s2);
    48 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcsncasecmp(const signed long int *__s1, const signed long int *__s2, unsigned int __n);
    49 struct __locale_struct {
    50     struct __locale_data *__locales[((unsigned int )13)];
    51     const unsigned short int *__ctype_b;
    52     const signed int *__ctype_tolower;
    53     const signed int *__ctype_toupper;
    54     const char *__names[((unsigned int )13)];
    55 };
    56 static inline void ___constructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1);
    57 static inline void ___constructor__F_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1);
    58 static inline void ___destructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1);
    59 static inline struct __locale_struct ___operator_assign__F16s__locale_struct_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1);
    60 static inline void ___constructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1){
    61     {
    62         signed int _index0 = ((signed int )0);
    63         for (;(_index0<13);((void)(++_index0))) {
    64             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index0])))) /* ?{} */);
    65         }
    66 
    67     }
    68     ((void)((*___dst__R16s__locale_struct_1).__ctype_b) /* ?{} */);
    69     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ?{} */);
    70     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    71     {
    72         signed int _index1 = ((signed int )0);
    73         for (;(_index1<13);((void)(++_index1))) {
    74             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index1])))) /* ?{} */);
    75         }
    76 
    77     }
    78 }
    79 static inline void ___constructor__F_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1){
    80     {
    81         signed int _index2 = ((signed int )0);
    82         for (;(_index2<13);((void)(++_index2))) {
    83             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index2])))=___src__16s__locale_struct_1.__locales[_index2]) /* ?{} */);
    84         }
    85 
    86     }
    87     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=___src__16s__locale_struct_1.__ctype_b) /* ?{} */);
    88     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=___src__16s__locale_struct_1.__ctype_tolower) /* ?{} */);
    89     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=___src__16s__locale_struct_1.__ctype_toupper) /* ?{} */);
    90     {
    91         signed int _index3 = ((signed int )0);
    92         for (;(_index3<13);((void)(++_index3))) {
    93             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index3])))=___src__16s__locale_struct_1.__names[_index3]) /* ?{} */);
    94         }
    95 
    96     }
    97 }
    98 static inline void ___destructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1){
    99     {
    100         signed int _index4 = ((signed int )(13-1));
    101         for (;(_index4>=0);((void)(--_index4))) {
    102             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index4])))) /* ^?{} */);
    103         }
    104 
    105     }
    106     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ^?{} */);
    107     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ^?{} */);
    108     ((void)((*___dst__R16s__locale_struct_1).__ctype_b) /* ^?{} */);
    109     {
    110         signed int _index5 = ((signed int )(13-1));
    111         for (;(_index5>=0);((void)(--_index5))) {
    112             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index5])))) /* ^?{} */);
    113         }
    114 
    115     }
    116 }
    117 static inline struct __locale_struct ___operator_assign__F16s__locale_struct_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1){
    118     struct __locale_struct ___ret__16s__locale_struct_1;
    119     {
    120         signed int _index6 = ((signed int )0);
    121         for (;(_index6<13);((void)(++_index6))) {
    122             ((void)((*___dst__R16s__locale_struct_1).__locales[_index6]=___src__16s__locale_struct_1.__locales[_index6]));
    123         }
    124 
    125     }
    126 
    127     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=___src__16s__locale_struct_1.__ctype_b));
    128     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=___src__16s__locale_struct_1.__ctype_tolower));
    129     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=___src__16s__locale_struct_1.__ctype_toupper));
    130     {
    131         signed int _index7 = ((signed int )0);
    132         for (;(_index7<13);((void)(++_index7))) {
    133             ((void)((*___dst__R16s__locale_struct_1).__names[_index7]=___src__16s__locale_struct_1.__names[_index7]));
    134         }
    135 
    136     }
    137 
    138     ((void)___constructor__F_R16s__locale_struct16s__locale_struct_autogen___1((&___ret__16s__locale_struct_1), ___src__16s__locale_struct_1));
    139     return ((struct __locale_struct )___ret__16s__locale_struct_1);
    140 }
    141 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_data_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned int )13)]){
    142     {
    143         signed int _index8 = ((signed int )0);
    144         for (;(_index8<13);((void)(++_index8))) {
    145             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index8])))=____locales__A0P14s__locale_data_1[_index8]) /* ?{} */);
    146         }
    147 
    148     }
    149     ((void)((*___dst__R16s__locale_struct_1).__ctype_b) /* ?{} */);
    150     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ?{} */);
    151     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    152     {
    153         signed int _index9 = ((signed int )0);
    154         for (;(_index9<13);((void)(++_index9))) {
    155             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index9])))) /* ?{} */);
    156         }
    157 
    158     }
    159 }
    160 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUs_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned int )13)], const unsigned short int *____ctype_b__PCUs_1){
    161     {
    162         signed int _index10 = ((signed int )0);
    163         for (;(_index10<13);((void)(++_index10))) {
    164             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index10])))=____locales__A0P14s__locale_data_1[_index10]) /* ?{} */);
    165         }
    166 
    167     }
    168     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    169     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ?{} */);
    170     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    171     {
    172         signed int _index11 = ((signed int )0);
    173         for (;(_index11<13);((void)(++_index11))) {
    174             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index11])))) /* ?{} */);
    175         }
    176 
    177     }
    178 }
    179 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUsPCi_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned int )13)], const unsigned short int *____ctype_b__PCUs_1, const signed int *____ctype_tolower__PCi_1){
    180     {
    181         signed int _index12 = ((signed int )0);
    182         for (;(_index12<13);((void)(++_index12))) {
    183             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index12])))=____locales__A0P14s__locale_data_1[_index12]) /* ?{} */);
    184         }
    185 
    186     }
    187     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    188     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=____ctype_tolower__PCi_1) /* ?{} */);
    189     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    190     {
    191         signed int _index13 = ((signed int )0);
    192         for (;(_index13<13);((void)(++_index13))) {
    193             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index13])))) /* ?{} */);
    194         }
    195 
    196     }
    197 }
    198 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUsPCiPCi_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned int )13)], const unsigned short int *____ctype_b__PCUs_1, const signed int *____ctype_tolower__PCi_1, const signed int *____ctype_toupper__PCi_1){
    199     {
    200         signed int _index14 = ((signed int )0);
    201         for (;(_index14<13);((void)(++_index14))) {
    202             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index14])))=____locales__A0P14s__locale_data_1[_index14]) /* ?{} */);
    203         }
    204 
    205     }
    206     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    207     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=____ctype_tolower__PCi_1) /* ?{} */);
    208     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=____ctype_toupper__PCi_1) /* ?{} */);
    209     {
    210         signed int _index15 = ((signed int )0);
    211         for (;(_index15<13);((void)(++_index15))) {
    212             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index15])))) /* ?{} */);
    213         }
    214 
    215     }
    216 }
    217 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUsPCiPCiA0PCc_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned int )13)], const unsigned short int *____ctype_b__PCUs_1, const signed int *____ctype_tolower__PCi_1, const signed int *____ctype_toupper__PCi_1, const char *____names__A0PCc_1[((unsigned int )13)]){
    218     {
    219         signed int _index16 = ((signed int )0);
    220         for (;(_index16<13);((void)(++_index16))) {
    221             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[_index16])))=____locales__A0P14s__locale_data_1[_index16]) /* ?{} */);
    222         }
    223 
    224     }
    225     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    226     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=____ctype_tolower__PCi_1) /* ?{} */);
    227     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=____ctype_toupper__PCi_1) /* ?{} */);
    228     {
    229         signed int _index17 = ((signed int )0);
    230         for (;(_index17<13);((void)(++_index17))) {
    231             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[_index17])))=____names__A0PCc_1[_index17]) /* ?{} */);
    232         }
    233 
    234     }
    235 }
    236 struct __locale_struct;
    237 struct __locale_struct;
    238 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscasecmp_l(const signed long int *__s1, const signed long int *__s2, struct __locale_struct *__loc);
    239 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcsncasecmp_l(const signed long int *__s1, const signed long int *__s2, unsigned int __n, struct __locale_struct *__loc);
    240 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscoll(const signed long int *__s1, const signed long int *__s2);
    241 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int wcsxfrm(signed long int *__restrict __s1, const signed long int *__restrict __s2, unsigned int __n);
    242 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscoll_l(const signed long int *__s1, const signed long int *__s2, struct __locale_struct *__loc);
    243 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int wcsxfrm_l(signed long int *__s1, const signed long int *__s2, unsigned int __n, struct __locale_struct *__loc);
    244 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern signed long int *wcsdup(const signed long int *__s);
    245 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed long int *wcschr(const signed long int *__wcs, signed long int __wc);
    246 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed long int *wcsrchr(const signed long int *__wcs, signed long int __wc);
    247 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned int wcscspn(const signed long int *__wcs, const signed long int *__reject);
    248 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned int wcsspn(const signed long int *__wcs, const signed long int *__accept);
    249 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed long int *wcspbrk(const signed long int *__wcs, const signed long int *__accept);
    250 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed long int *wcsstr(const signed long int *__haystack, const signed long int *__needle);
    251 __attribute__ ((__nothrow__,__leaf__)) extern signed long int *wcstok(signed long int *__restrict __s, const signed long int *__restrict __delim, signed long int **__restrict __ptr);
    252 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned int wcslen(const signed long int *__s);
    253 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned int wcsnlen(const signed long int *__s, unsigned int __maxlen);
    254 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed long int *wmemchr(const signed long int *__s, signed long int __c, unsigned int __n);
    255 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int wmemcmp(const signed long int *__s1, const signed long int *__s2, unsigned int __n);
    256 __attribute__ ((__nothrow__,__leaf__)) extern signed long int *wmemcpy(signed long int *__restrict __s1, const signed long int *__restrict __s2, unsigned int __n);
    257 __attribute__ ((__nothrow__,__leaf__)) extern signed long int *wmemmove(signed long int *__s1, const signed long int *__s2, unsigned int __n);
    258 __attribute__ ((__nothrow__,__leaf__)) extern signed long int *wmemset(signed long int *__s, signed long int __c, unsigned int __n);
    259 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int btowc(signed int __c);
    260 __attribute__ ((__nothrow__,__leaf__)) extern signed int wctob(unsigned int __c);
    261 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int mbsinit(const struct __anonymous1 *__ps);
    262 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int mbrtowc(signed long int *__restrict __pwc, const char *__restrict __s, unsigned int __n, struct __anonymous1 *__restrict __p);
    263 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int wcrtomb(char *__restrict __s, signed long int __wc, struct __anonymous1 *__restrict __ps);
    264 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int __mbrlen(const char *__restrict __s, unsigned int __n, struct __anonymous1 *__restrict __ps);
    265 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int mbrlen(const char *__restrict __s, unsigned int __n, struct __anonymous1 *__restrict __ps);
    266 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int mbsrtowcs(signed long int *__restrict __dst, const char **__restrict __src, unsigned int __len, struct __anonymous1 *__restrict __ps);
    267 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int wcsrtombs(char *__restrict __dst, const signed long int **__restrict __src, unsigned int __len, struct __anonymous1 *__restrict __ps);
    268 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int mbsnrtowcs(signed long int *__restrict __dst, const char **__restrict __src, unsigned int __nmc, unsigned int __len, struct __anonymous1 *__restrict __ps);
    269 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int wcsnrtombs(char *__restrict __dst, const signed long int **__restrict __src, unsigned int __nwc, unsigned int __len, struct __anonymous1 *__restrict __ps);
    270 __attribute__ ((__nothrow__,__leaf__)) extern double wcstod(const signed long int *__restrict __nptr, signed long int **__restrict __endptr);
    271 __attribute__ ((__nothrow__,__leaf__)) extern float wcstof(const signed long int *__restrict __nptr, signed long int **__restrict __endptr);
    272 __attribute__ ((__nothrow__,__leaf__)) extern long double wcstold(const signed long int *__restrict __nptr, signed long int **__restrict __endptr);
    273 __attribute__ ((__nothrow__,__leaf__)) extern signed long int wcstol(const signed long int *__restrict __nptr, signed long int **__restrict __endptr, signed int __base);
    274 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcstoul(const signed long int *__restrict __nptr, signed long int **__restrict __endptr, signed int __base);
    275 __extension__ __attribute__ ((__nothrow__,__leaf__)) extern signed long long int wcstoll(const signed long int *__restrict __nptr, signed long int **__restrict __endptr, signed int __base);
    276 __extension__ __attribute__ ((__nothrow__,__leaf__)) extern unsigned long long int wcstoull(const signed long int *__restrict __nptr, signed long int **__restrict __endptr, signed int __base);
    277 __attribute__ ((__nothrow__,__leaf__)) extern signed long int *wcpcpy(signed long int *__restrict __dest, const signed long int *__restrict __src);
    278 __attribute__ ((__nothrow__,__leaf__)) extern signed long int *wcpncpy(signed long int *__restrict __dest, const signed long int *__restrict __src, unsigned int __n);
    279 __attribute__ ((__nothrow__,__leaf__)) extern struct _IO_FILE *open_wmemstream(signed long int **__bufloc, unsigned int *__sizeloc);
    280 __attribute__ ((__nothrow__,__leaf__)) extern signed int fwide(struct _IO_FILE *__fp, signed int __mode);
    281 extern signed int fwprintf(struct _IO_FILE *__restrict __stream, const signed long int *__restrict __format, ...);
    282 extern signed int wprintf(const signed long int *__restrict __format, ...);
    283 __attribute__ ((__nothrow__,__leaf__)) extern signed int swprintf(signed long int *__restrict __s, unsigned int __n, const signed long int *__restrict __format, ...);
    284 extern signed int vfwprintf(struct _IO_FILE *__restrict __s, const signed long int *__restrict __format, __builtin_va_list __arg);
    285 extern signed int vwprintf(const signed long int *__restrict __format, __builtin_va_list __arg);
    286 __attribute__ ((__nothrow__,__leaf__)) extern signed int vswprintf(signed long int *__restrict __s, unsigned int __n, const signed long int *__restrict __format, __builtin_va_list __arg);
    287 extern signed int fwscanf(struct _IO_FILE *__restrict __stream, const signed long int *__restrict __format, ...);
    288 extern signed int wscanf(const signed long int *__restrict __format, ...);
    289 __attribute__ ((__nothrow__,__leaf__)) extern signed int swscanf(const signed long int *__restrict __s, const signed long int *__restrict __format, ...);
    290 extern signed int fwscanf(struct _IO_FILE *__restrict __stream, const signed long int *__restrict __format, ...) asm ( "" "__isoc99_fwscanf" );
    291 extern signed int wscanf(const signed long int *__restrict __format, ...) asm ( "" "__isoc99_wscanf" );
    292 __attribute__ ((__nothrow__,__leaf__)) extern signed int swscanf(const signed long int *__restrict __s, const signed long int *__restrict __format, ...) asm ( "" "__isoc99_swscanf" );
    293 extern signed int vfwscanf(struct _IO_FILE *__restrict __s, const signed long int *__restrict __format, __builtin_va_list __arg);
    294 extern signed int vwscanf(const signed long int *__restrict __format, __builtin_va_list __arg);
    295 __attribute__ ((__nothrow__,__leaf__)) extern signed int vswscanf(const signed long int *__restrict __s, const signed long int *__restrict __format, __builtin_va_list __arg);
    296 extern signed int vfwscanf(struct _IO_FILE *__restrict __s, const signed long int *__restrict __format, __builtin_va_list __arg) asm ( "" "__isoc99_vfwscanf" );
    297 extern signed int vwscanf(const signed long int *__restrict __format, __builtin_va_list __arg) asm ( "" "__isoc99_vwscanf" );
    298 __attribute__ ((__nothrow__,__leaf__)) extern signed int vswscanf(const signed long int *__restrict __s, const signed long int *__restrict __format, __builtin_va_list __arg) asm ( "" "__isoc99_vswscanf" );
    299 extern unsigned int fgetwc(struct _IO_FILE *__stream);
    300 extern unsigned int getwc(struct _IO_FILE *__stream);
    301 extern unsigned int getwchar(void);
    302 extern unsigned int fputwc(signed long int __wc, struct _IO_FILE *__stream);
    303 extern unsigned int putwc(signed long int __wc, struct _IO_FILE *__stream);
    304 extern unsigned int putwchar(signed long int __wc);
    305 extern signed long int *fgetws(signed long int *__restrict __ws, signed int __n, struct _IO_FILE *__restrict __stream);
    306 extern signed int fputws(const signed long int *__restrict __ws, struct _IO_FILE *__restrict __stream);
    307 extern unsigned int ungetwc(unsigned int __wc, struct _IO_FILE *__stream);
    308 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int wcsftime(signed long int *__restrict __s, unsigned int __maxsize, const signed long int *__restrict __format, const struct tm *__restrict __tp);
    3097void __for_each__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
    3108void __for_each_reverse__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
     
    423121struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1283, signed int __size__i_1);
    424122void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1285), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
    425 enum __anonymous2 {
    426     __sepSize__C13e__anonymous2_1 = ((signed int )16),
     123enum __anonymous0 {
     124    __sepSize__C13e__anonymous0_1 = ((signed int )16),
    427125};
    428126struct ofstream {
     
    432130    _Bool __sawNL__b_1;
    433131    const char *__sepCur__PCc_1;
    434     char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous2_1)];
    435     char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous2_1)];
     132    char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)];
     133    char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)];
    436134};
    437135static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
     
    446144    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    447145    {
    448         signed int _index18 = ((signed int )0);
    449         for (;(_index18<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index18))) {
    450             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index18])))) /* ?{} */);
    451         }
    452 
    453     }
    454     {
    455         signed int _index19 = ((signed int )0);
    456         for (;(_index19<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index19))) {
    457             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index19])))) /* ?{} */);
     146        signed int _index0 = ((signed int )0);
     147        for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
     148            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index0])))) /* ?{} */);
     149        }
     150
     151    }
     152    {
     153        signed int _index1 = ((signed int )0);
     154        for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
     155            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index1])))) /* ?{} */);
    458156        }
    459157
     
    467165    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
    468166    {
    469         signed int _index20 = ((signed int )0);
    470         for (;(_index20<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index20))) {
    471             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index20])))=___src__9sofstream_1.__separator__A0c_1[_index20]) /* ?{} */);
    472         }
    473 
    474     }
    475     {
    476         signed int _index21 = ((signed int )0);
    477         for (;(_index21<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index21))) {
    478             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21])))=___src__9sofstream_1.__tupleSeparator__A0c_1[_index21]) /* ?{} */);
     167        signed int _index2 = ((signed int )0);
     168        for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
     169            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index2])))=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
     170        }
     171
     172    }
     173    {
     174        signed int _index3 = ((signed int )0);
     175        for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
     176            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index3])))=___src__9sofstream_1.__tupleSeparator__A0c_1[_index3]) /* ?{} */);
    479177        }
    480178
     
    483181static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
    484182    {
    485         signed int _index22 = ((signed int )(((signed int )__sepSize__C13e__anonymous2_1)-1));
    486         for (;(_index22>=0);((void)(--_index22))) {
    487             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index22])))) /* ^?{} */);
    488         }
    489 
    490     }
    491     {
    492         signed int _index23 = ((signed int )(((signed int )__sepSize__C13e__anonymous2_1)-1));
    493         for (;(_index23>=0);((void)(--_index23))) {
    494             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index23])))) /* ^?{} */);
     183        signed int _index4 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
     184        for (;(_index4>=0);((void)(--_index4))) {
     185            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index4])))) /* ^?{} */);
     186        }
     187
     188    }
     189    {
     190        signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
     191        for (;(_index5>=0);((void)(--_index5))) {
     192            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index5])))) /* ^?{} */);
    495193        }
    496194
     
    510208    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
    511209    {
    512         signed int _index24 = ((signed int )0);
    513         for (;(_index24<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index24))) {
    514             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index24]=___src__9sofstream_1.__separator__A0c_1[_index24]));
    515         }
    516 
    517     }
    518 
    519     {
    520         signed int _index25 = ((signed int )0);
    521         for (;(_index25<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index25))) {
    522             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index25]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index25]));
     210        signed int _index6 = ((signed int )0);
     211        for (;(_index6<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index6))) {
     212            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index6]=___src__9sofstream_1.__separator__A0c_1[_index6]));
     213        }
     214
     215    }
     216
     217    {
     218        signed int _index7 = ((signed int )0);
     219        for (;(_index7<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index7))) {
     220            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index7]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index7]));
    523221        }
    524222
     
    535233    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    536234    {
    537         signed int _index26 = ((signed int )0);
    538         for (;(_index26<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index26))) {
    539             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index26])))) /* ?{} */);
    540         }
    541 
    542     }
    543     {
    544         signed int _index27 = ((signed int )0);
    545         for (;(_index27<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index27))) {
    546             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index27])))) /* ?{} */);
     235        signed int _index8 = ((signed int )0);
     236        for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
     237            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index8])))) /* ?{} */);
     238        }
     239
     240    }
     241    {
     242        signed int _index9 = ((signed int )0);
     243        for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
     244            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index9])))) /* ?{} */);
    547245        }
    548246
     
    556254    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    557255    {
    558         signed int _index28 = ((signed int )0);
    559         for (;(_index28<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index28))) {
    560             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index28])))) /* ?{} */);
    561         }
    562 
    563     }
    564     {
    565         signed int _index29 = ((signed int )0);
    566         for (;(_index29<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index29))) {
    567             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index29])))) /* ?{} */);
     256        signed int _index10 = ((signed int )0);
     257        for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
     258            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index10])))) /* ?{} */);
     259        }
     260
     261    }
     262    {
     263        signed int _index11 = ((signed int )0);
     264        for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
     265            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index11])))) /* ?{} */);
    568266        }
    569267
     
    577275    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    578276    {
    579         signed int _index30 = ((signed int )0);
    580         for (;(_index30<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index30))) {
    581             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index30])))) /* ?{} */);
    582         }
    583 
    584     }
    585     {
    586         signed int _index31 = ((signed int )0);
    587         for (;(_index31<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index31))) {
    588             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index31])))) /* ?{} */);
     277        signed int _index12 = ((signed int )0);
     278        for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
     279            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index12])))) /* ?{} */);
     280        }
     281
     282    }
     283    {
     284        signed int _index13 = ((signed int )0);
     285        for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
     286            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index13])))) /* ?{} */);
    589287        }
    590288
     
    598296    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    599297    {
    600         signed int _index32 = ((signed int )0);
    601         for (;(_index32<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index32))) {
    602             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index32])))) /* ?{} */);
    603         }
    604 
    605     }
    606     {
    607         signed int _index33 = ((signed int )0);
    608         for (;(_index33<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index33))) {
    609             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index33])))) /* ?{} */);
     298        signed int _index14 = ((signed int )0);
     299        for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
     300            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index14])))) /* ?{} */);
     301        }
     302
     303    }
     304    {
     305        signed int _index15 = ((signed int )0);
     306        for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
     307            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index15])))) /* ?{} */);
    610308        }
    611309
     
    619317    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
    620318    {
    621         signed int _index34 = ((signed int )0);
    622         for (;(_index34<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index34))) {
    623             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index34])))) /* ?{} */);
    624         }
    625 
    626     }
    627     {
    628         signed int _index35 = ((signed int )0);
    629         for (;(_index35<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index35))) {
    630             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index35])))) /* ?{} */);
    631         }
    632 
    633     }
    634 }
    635 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous2_1)]){
     319        signed int _index16 = ((signed int )0);
     320        for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
     321            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index16])))) /* ?{} */);
     322        }
     323
     324    }
     325    {
     326        signed int _index17 = ((signed int )0);
     327        for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
     328            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index17])))) /* ?{} */);
     329        }
     330
     331    }
     332}
     333static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]){
    636334    ((void)((*___dst__R9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
    637335    ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     
    640338    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
    641339    {
    642         signed int _index36 = ((signed int )0);
    643         for (;(_index36<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index36))) {
    644             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index36])))=__separator__A0c_1[_index36]) /* ?{} */);
    645         }
    646 
    647     }
    648     {
    649         signed int _index37 = ((signed int )0);
    650         for (;(_index37<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index37))) {
    651             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index37])))) /* ?{} */);
    652         }
    653 
    654     }
    655 }
    656 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous2_1)], char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous2_1)]){
     340        signed int _index18 = ((signed int )0);
     341        for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
     342            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index18])))=__separator__A0c_1[_index18]) /* ?{} */);
     343        }
     344
     345    }
     346    {
     347        signed int _index19 = ((signed int )0);
     348        for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
     349            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index19])))) /* ?{} */);
     350        }
     351
     352    }
     353}
     354static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]){
    657355    ((void)((*___dst__R9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
    658356    ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     
    661359    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
    662360    {
    663         signed int _index38 = ((signed int )0);
    664         for (;(_index38<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index38))) {
    665             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index38])))=__separator__A0c_1[_index38]) /* ?{} */);
    666         }
    667 
    668     }
    669     {
    670         signed int _index39 = ((signed int )0);
    671         for (;(_index39<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index39))) {
    672             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index39])))=__tupleSeparator__A0c_1[_index39]) /* ?{} */);
     361        signed int _index20 = ((signed int )0);
     362        for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
     363            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index20])))=__separator__A0c_1[_index20]) /* ?{} */);
     364        }
     365
     366    }
     367    {
     368        signed int _index21 = ((signed int )0);
     369        for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
     370            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21])))=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
    673371        }
    674372
  • src/tests/.expect/64/literals.txt

    red235b6 r8024bc8  
    55__attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
    66extern signed int printf(const char *__restrict __format, ...);
    7 union __anonymous0 {
    8     unsigned int __wch;
    9     char __wchb[((unsigned long int )4)];
    10 };
    11 static inline void ___constructor__F_R13u__anonymous0_autogen___1(__attribute__ ((unused)) union __anonymous0 *___dst__R13u__anonymous0_1){
    12 }
    13 static inline void ___constructor__F_R13u__anonymous013u__anonymous0_autogen___1(union __anonymous0 *___dst__R13u__anonymous0_1, union __anonymous0 ___src__13u__anonymous0_1){
    14     ((void)__builtin_memcpy(((void *)___dst__R13u__anonymous0_1), ((const void *)(&___src__13u__anonymous0_1)), sizeof(union __anonymous0 )));
    15 }
    16 static inline void ___destructor__F_R13u__anonymous0_autogen___1(__attribute__ ((unused)) union __anonymous0 *___dst__R13u__anonymous0_1){
    17 }
    18 static inline union __anonymous0 ___operator_assign__F13u__anonymous0_R13u__anonymous013u__anonymous0_autogen___1(union __anonymous0 *___dst__R13u__anonymous0_1, union __anonymous0 ___src__13u__anonymous0_1){
    19     union __anonymous0 ___ret__13u__anonymous0_1;
    20     ((void)__builtin_memcpy(((void *)___dst__R13u__anonymous0_1), ((const void *)(&___src__13u__anonymous0_1)), sizeof(union __anonymous0 )));
    21     ((void)___constructor__F_R13u__anonymous013u__anonymous0_autogen___1((&___ret__13u__anonymous0_1), ___src__13u__anonymous0_1));
    22     return ((union __anonymous0 )___ret__13u__anonymous0_1);
    23 }
    24 static inline void ___constructor__F_R13u__anonymous0Ui_autogen___1(__attribute__ ((unused)) union __anonymous0 *___dst__R13u__anonymous0_1, unsigned int __src__Ui_1){
    25     ((void)__builtin_memcpy(((void *)___dst__R13u__anonymous0_1), ((const void *)(&__src__Ui_1)), sizeof(unsigned int )));
    26 }
    27 struct __anonymous1 {
    28     signed int __count;
    29     union __anonymous0 __value;
    30 };
    31 struct __anonymous1;
    32 struct __anonymous1;
    33 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int mbrtoc16(unsigned short int *__restrict __pc16, const char *__restrict __s, unsigned long int __n, struct __anonymous1 *__restrict __p);
    34 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int c16rtomb(char *__restrict __s, unsigned short int __c16, struct __anonymous1 *__restrict __ps);
    35 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int mbrtoc32(unsigned int *__restrict __pc32, const char *__restrict __s, unsigned long int __n, struct __anonymous1 *__restrict __p);
    36 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int c32rtomb(char *__restrict __s, unsigned int __c32, struct __anonymous1 *__restrict __ps);
    37 struct _IO_FILE;
    38 struct _IO_FILE;
    39 struct _IO_FILE;
    40 struct tm;
    41 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed int *wcscpy(signed int *__restrict __dest, const signed int *__restrict __src);
    42 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed int *wcsncpy(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n);
    43 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed int *wcscat(signed int *__restrict __dest, const signed int *__restrict __src);
    44 __attribute__ ((__nothrow__,__leaf__,__nonnull__(1, 2))) extern signed int *wcsncat(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n);
    45 __attribute__ ((__nothrow__,__leaf__,__pure__,__nonnull__(1, 2))) extern signed int wcscmp(const signed int *__s1, const signed int *__s2);
    46 __attribute__ ((__nothrow__,__leaf__,__pure__,__nonnull__(1, 2))) extern signed int wcsncmp(const signed int *__s1, const signed int *__s2, unsigned long int __n);
    47 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscasecmp(const signed int *__s1, const signed int *__s2);
    48 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcsncasecmp(const signed int *__s1, const signed int *__s2, unsigned long int __n);
    49 struct __locale_struct {
    50     struct __locale_data *__locales[((unsigned long int )13)];
    51     const unsigned short int *__ctype_b;
    52     const signed int *__ctype_tolower;
    53     const signed int *__ctype_toupper;
    54     const char *__names[((unsigned long int )13)];
    55 };
    56 static inline void ___constructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1);
    57 static inline void ___constructor__F_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1);
    58 static inline void ___destructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1);
    59 static inline struct __locale_struct ___operator_assign__F16s__locale_struct_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1);
    60 static inline void ___constructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1){
    61     {
    62         signed int _index0 = ((signed int )0);
    63         for (;(_index0<13);((void)(++_index0))) {
    64             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index0)])))) /* ?{} */);
    65         }
    66 
    67     }
    68     ((void)((*___dst__R16s__locale_struct_1).__ctype_b) /* ?{} */);
    69     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ?{} */);
    70     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    71     {
    72         signed int _index1 = ((signed int )0);
    73         for (;(_index1<13);((void)(++_index1))) {
    74             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index1)])))) /* ?{} */);
    75         }
    76 
    77     }
    78 }
    79 static inline void ___constructor__F_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1){
    80     {
    81         signed int _index2 = ((signed int )0);
    82         for (;(_index2<13);((void)(++_index2))) {
    83             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index2)])))=___src__16s__locale_struct_1.__locales[((signed long int )_index2)]) /* ?{} */);
    84         }
    85 
    86     }
    87     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=___src__16s__locale_struct_1.__ctype_b) /* ?{} */);
    88     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=___src__16s__locale_struct_1.__ctype_tolower) /* ?{} */);
    89     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=___src__16s__locale_struct_1.__ctype_toupper) /* ?{} */);
    90     {
    91         signed int _index3 = ((signed int )0);
    92         for (;(_index3<13);((void)(++_index3))) {
    93             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index3)])))=___src__16s__locale_struct_1.__names[((signed long int )_index3)]) /* ?{} */);
    94         }
    95 
    96     }
    97 }
    98 static inline void ___destructor__F_R16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1){
    99     {
    100         signed int _index4 = ((signed int )(13-1));
    101         for (;(_index4>=0);((void)(--_index4))) {
    102             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index4)])))) /* ^?{} */);
    103         }
    104 
    105     }
    106     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ^?{} */);
    107     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ^?{} */);
    108     ((void)((*___dst__R16s__locale_struct_1).__ctype_b) /* ^?{} */);
    109     {
    110         signed int _index5 = ((signed int )(13-1));
    111         for (;(_index5>=0);((void)(--_index5))) {
    112             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index5)])))) /* ^?{} */);
    113         }
    114 
    115     }
    116 }
    117 static inline struct __locale_struct ___operator_assign__F16s__locale_struct_R16s__locale_struct16s__locale_struct_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_struct ___src__16s__locale_struct_1){
    118     struct __locale_struct ___ret__16s__locale_struct_1;
    119     {
    120         signed int _index6 = ((signed int )0);
    121         for (;(_index6<13);((void)(++_index6))) {
    122             ((void)((*___dst__R16s__locale_struct_1).__locales[((signed long int )_index6)]=___src__16s__locale_struct_1.__locales[((signed long int )_index6)]));
    123         }
    124 
    125     }
    126 
    127     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=___src__16s__locale_struct_1.__ctype_b));
    128     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=___src__16s__locale_struct_1.__ctype_tolower));
    129     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=___src__16s__locale_struct_1.__ctype_toupper));
    130     {
    131         signed int _index7 = ((signed int )0);
    132         for (;(_index7<13);((void)(++_index7))) {
    133             ((void)((*___dst__R16s__locale_struct_1).__names[((signed long int )_index7)]=___src__16s__locale_struct_1.__names[((signed long int )_index7)]));
    134         }
    135 
    136     }
    137 
    138     ((void)___constructor__F_R16s__locale_struct16s__locale_struct_autogen___1((&___ret__16s__locale_struct_1), ___src__16s__locale_struct_1));
    139     return ((struct __locale_struct )___ret__16s__locale_struct_1);
    140 }
    141 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_data_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned long int )13)]){
    142     {
    143         signed int _index8 = ((signed int )0);
    144         for (;(_index8<13);((void)(++_index8))) {
    145             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index8)])))=____locales__A0P14s__locale_data_1[((signed long int )_index8)]) /* ?{} */);
    146         }
    147 
    148     }
    149     ((void)((*___dst__R16s__locale_struct_1).__ctype_b) /* ?{} */);
    150     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ?{} */);
    151     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    152     {
    153         signed int _index9 = ((signed int )0);
    154         for (;(_index9<13);((void)(++_index9))) {
    155             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index9)])))) /* ?{} */);
    156         }
    157 
    158     }
    159 }
    160 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUs_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned long int )13)], const unsigned short int *____ctype_b__PCUs_1){
    161     {
    162         signed int _index10 = ((signed int )0);
    163         for (;(_index10<13);((void)(++_index10))) {
    164             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index10)])))=____locales__A0P14s__locale_data_1[((signed long int )_index10)]) /* ?{} */);
    165         }
    166 
    167     }
    168     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    169     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower) /* ?{} */);
    170     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    171     {
    172         signed int _index11 = ((signed int )0);
    173         for (;(_index11<13);((void)(++_index11))) {
    174             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index11)])))) /* ?{} */);
    175         }
    176 
    177     }
    178 }
    179 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUsPCi_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned long int )13)], const unsigned short int *____ctype_b__PCUs_1, const signed int *____ctype_tolower__PCi_1){
    180     {
    181         signed int _index12 = ((signed int )0);
    182         for (;(_index12<13);((void)(++_index12))) {
    183             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index12)])))=____locales__A0P14s__locale_data_1[((signed long int )_index12)]) /* ?{} */);
    184         }
    185 
    186     }
    187     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    188     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=____ctype_tolower__PCi_1) /* ?{} */);
    189     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper) /* ?{} */);
    190     {
    191         signed int _index13 = ((signed int )0);
    192         for (;(_index13<13);((void)(++_index13))) {
    193             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index13)])))) /* ?{} */);
    194         }
    195 
    196     }
    197 }
    198 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUsPCiPCi_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned long int )13)], const unsigned short int *____ctype_b__PCUs_1, const signed int *____ctype_tolower__PCi_1, const signed int *____ctype_toupper__PCi_1){
    199     {
    200         signed int _index14 = ((signed int )0);
    201         for (;(_index14<13);((void)(++_index14))) {
    202             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index14)])))=____locales__A0P14s__locale_data_1[((signed long int )_index14)]) /* ?{} */);
    203         }
    204 
    205     }
    206     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    207     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=____ctype_tolower__PCi_1) /* ?{} */);
    208     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=____ctype_toupper__PCi_1) /* ?{} */);
    209     {
    210         signed int _index15 = ((signed int )0);
    211         for (;(_index15<13);((void)(++_index15))) {
    212             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index15)])))) /* ?{} */);
    213         }
    214 
    215     }
    216 }
    217 static inline void ___constructor__F_R16s__locale_structA0P14s__locale_dataPCUsPCiPCiA0PCc_autogen___1(struct __locale_struct *___dst__R16s__locale_struct_1, struct __locale_data *____locales__A0P14s__locale_data_1[((unsigned long int )13)], const unsigned short int *____ctype_b__PCUs_1, const signed int *____ctype_tolower__PCi_1, const signed int *____ctype_toupper__PCi_1, const char *____names__A0PCc_1[((unsigned long int )13)]){
    218     {
    219         signed int _index16 = ((signed int )0);
    220         for (;(_index16<13);((void)(++_index16))) {
    221             ((void)((*((struct __locale_data **)(&(*___dst__R16s__locale_struct_1).__locales[((signed long int )_index16)])))=____locales__A0P14s__locale_data_1[((signed long int )_index16)]) /* ?{} */);
    222         }
    223 
    224     }
    225     ((void)((*___dst__R16s__locale_struct_1).__ctype_b=____ctype_b__PCUs_1) /* ?{} */);
    226     ((void)((*___dst__R16s__locale_struct_1).__ctype_tolower=____ctype_tolower__PCi_1) /* ?{} */);
    227     ((void)((*___dst__R16s__locale_struct_1).__ctype_toupper=____ctype_toupper__PCi_1) /* ?{} */);
    228     {
    229         signed int _index17 = ((signed int )0);
    230         for (;(_index17<13);((void)(++_index17))) {
    231             ((void)((*((const char **)(&(*___dst__R16s__locale_struct_1).__names[((signed long int )_index17)])))=____names__A0PCc_1[((signed long int )_index17)]) /* ?{} */);
    232         }
    233 
    234     }
    235 }
    236 struct __locale_struct;
    237 struct __locale_struct;
    238 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscasecmp_l(const signed int *__s1, const signed int *__s2, struct __locale_struct *__loc);
    239 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcsncasecmp_l(const signed int *__s1, const signed int *__s2, unsigned long int __n, struct __locale_struct *__loc);
    240 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscoll(const signed int *__s1, const signed int *__s2);
    241 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcsxfrm(signed int *__restrict __s1, const signed int *__restrict __s2, unsigned long int __n);
    242 __attribute__ ((__nothrow__,__leaf__)) extern signed int wcscoll_l(const signed int *__s1, const signed int *__s2, struct __locale_struct *__loc);
    243 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcsxfrm_l(signed int *__s1, const signed int *__s2, unsigned long int __n, struct __locale_struct *__loc);
    244 __attribute__ ((__nothrow__,__leaf__,__malloc__)) extern signed int *wcsdup(const signed int *__s);
    245 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int *wcschr(const signed int *__wcs, signed int __wc);
    246 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int *wcsrchr(const signed int *__wcs, signed int __wc);
    247 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned long int wcscspn(const signed int *__wcs, const signed int *__reject);
    248 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned long int wcsspn(const signed int *__wcs, const signed int *__accept);
    249 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int *wcspbrk(const signed int *__wcs, const signed int *__accept);
    250 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int *wcsstr(const signed int *__haystack, const signed int *__needle);
    251 __attribute__ ((__nothrow__,__leaf__)) extern signed int *wcstok(signed int *__restrict __s, const signed int *__restrict __delim, signed int **__restrict __ptr);
    252 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned long int wcslen(const signed int *__s);
    253 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern unsigned long int wcsnlen(const signed int *__s, unsigned long int __maxlen);
    254 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int *wmemchr(const signed int *__s, signed int __c, unsigned long int __n);
    255 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int wmemcmp(const signed int *__s1, const signed int *__s2, unsigned long int __n);
    256 __attribute__ ((__nothrow__,__leaf__)) extern signed int *wmemcpy(signed int *__restrict __s1, const signed int *__restrict __s2, unsigned long int __n);
    257 __attribute__ ((__nothrow__,__leaf__)) extern signed int *wmemmove(signed int *__s1, const signed int *__s2, unsigned long int __n);
    258 __attribute__ ((__nothrow__,__leaf__)) extern signed int *wmemset(signed int *__s, signed int __c, unsigned long int __n);
    259 __attribute__ ((__nothrow__,__leaf__)) extern unsigned int btowc(signed int __c);
    260 __attribute__ ((__nothrow__,__leaf__)) extern signed int wctob(unsigned int __c);
    261 __attribute__ ((__nothrow__,__leaf__,__pure__)) extern signed int mbsinit(const struct __anonymous1 *__ps);
    262 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int mbrtowc(signed int *__restrict __pwc, const char *__restrict __s, unsigned long int __n, struct __anonymous1 *__restrict __p);
    263 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcrtomb(char *__restrict __s, signed int __wc, struct __anonymous1 *__restrict __ps);
    264 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int __mbrlen(const char *__restrict __s, unsigned long int __n, struct __anonymous1 *__restrict __ps);
    265 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int mbrlen(const char *__restrict __s, unsigned long int __n, struct __anonymous1 *__restrict __ps);
    266 extern unsigned int __btowc_alias(signed int __c) asm ( "btowc" );
    267 __attribute__ ((__nothrow__,__leaf__)) extern inline unsigned int btowc(signed int __c){
    268     __attribute__ ((unused)) unsigned int ___retval_btowc__Ui_1;
    269     unsigned int _tmp_cp_ret0;
    270     ((void)(___retval_btowc__Ui_1=(((signed int )((((signed int )((((signed int )(__builtin_constant_p(__c)!=((signed int )0))) && ((signed int )((__c>=((signed int )'\0'))!=((signed int )0))))!=((signed int )0))) && ((signed int )((__c<=((signed int )'\x7f'))!=((signed int )0))))!=((signed int )0))) ? ((unsigned int )__c) : (((void)(_tmp_cp_ret0=__btowc_alias(__c))) , _tmp_cp_ret0))) /* ?{} */);
    271     ((void)(_tmp_cp_ret0) /* ^?{} */);
    272     return ((unsigned int )___retval_btowc__Ui_1);
    273 }
    274 extern signed int __wctob_alias(unsigned int __c) asm ( "wctob" );
    275 __attribute__ ((__nothrow__,__leaf__)) extern inline signed int wctob(unsigned int __wc){
    276     __attribute__ ((unused)) signed int ___retval_wctob__i_1;
    277     signed int _tmp_cp_ret1;
    278     ((void)(___retval_wctob__i_1=(((signed int )((((signed int )((((signed int )(__builtin_constant_p(__wc)!=((signed int )0))) && ((signed int )((__wc>=((unsigned int )L'\0'))!=((signed int )0))))!=((signed int )0))) && ((signed int )((__wc<=((unsigned int )L'\x7f'))!=((signed int )0))))!=((signed int )0))) ? ((signed int )__wc) : (((void)(_tmp_cp_ret1=__wctob_alias(__wc))) , _tmp_cp_ret1))) /* ?{} */);
    279     ((void)(_tmp_cp_ret1) /* ^?{} */);
    280     return ((signed int )___retval_wctob__i_1);
    281 }
    282 __attribute__ ((__nothrow__,__leaf__)) extern inline unsigned long int mbrlen(const char *__restrict __s, unsigned long int __n, struct __anonymous1 *__restrict __ps){
    283     __attribute__ ((unused)) unsigned long int ___retval_mbrlen__Ul_1;
    284     unsigned long int _tmp_cp_ret2;
    285     unsigned long int _tmp_cp_ret3;
    286     ((void)(___retval_mbrlen__Ul_1=(((signed int )((((long int )__ps)!=((long int )((void *)0)))!=((signed int )0))) ? (((void)(_tmp_cp_ret2=mbrtowc(((signed int *__restrict )((void *)0)), __s, __n, __ps))) , _tmp_cp_ret2) : (((void)(_tmp_cp_ret3=__mbrlen(__s, __n, ((struct __anonymous1 *__restrict )((void *)0))))) , _tmp_cp_ret3))) /* ?{} */);
    287     ((void)(_tmp_cp_ret2) /* ^?{} */);
    288     ((void)(_tmp_cp_ret3) /* ^?{} */);
    289     return ((unsigned long int )___retval_mbrlen__Ul_1);
    290 }
    291 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int mbsrtowcs(signed int *__restrict __dst, const char **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps);
    292 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcsrtombs(char *__restrict __dst, const signed int **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps);
    293 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int mbsnrtowcs(signed int *__restrict __dst, const char **__restrict __src, unsigned long int __nmc, unsigned long int __len, struct __anonymous1 *__restrict __ps);
    294 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcsnrtombs(char *__restrict __dst, const signed int **__restrict __src, unsigned long int __nwc, unsigned long int __len, struct __anonymous1 *__restrict __ps);
    295 __attribute__ ((__nothrow__,__leaf__)) extern double wcstod(const signed int *__restrict __nptr, signed int **__restrict __endptr);
    296 __attribute__ ((__nothrow__,__leaf__)) extern float wcstof(const signed int *__restrict __nptr, signed int **__restrict __endptr);
    297 __attribute__ ((__nothrow__,__leaf__)) extern long double wcstold(const signed int *__restrict __nptr, signed int **__restrict __endptr);
    298 __attribute__ ((__nothrow__,__leaf__)) extern signed long int wcstol(const signed int *__restrict __nptr, signed int **__restrict __endptr, signed int __base);
    299 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcstoul(const signed int *__restrict __nptr, signed int **__restrict __endptr, signed int __base);
    300 __extension__ __attribute__ ((__nothrow__,__leaf__)) extern signed long long int wcstoll(const signed int *__restrict __nptr, signed int **__restrict __endptr, signed int __base);
    301 __extension__ __attribute__ ((__nothrow__,__leaf__)) extern unsigned long long int wcstoull(const signed int *__restrict __nptr, signed int **__restrict __endptr, signed int __base);
    302 __attribute__ ((__nothrow__,__leaf__)) extern signed int *wcpcpy(signed int *__restrict __dest, const signed int *__restrict __src);
    303 __attribute__ ((__nothrow__,__leaf__)) extern signed int *wcpncpy(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n);
    304 __attribute__ ((__nothrow__,__leaf__)) extern struct _IO_FILE *open_wmemstream(signed int **__bufloc, unsigned long int *__sizeloc);
    305 __attribute__ ((__nothrow__,__leaf__)) extern signed int fwide(struct _IO_FILE *__fp, signed int __mode);
    306 extern signed int fwprintf(struct _IO_FILE *__restrict __stream, const signed int *__restrict __format, ...);
    307 extern signed int wprintf(const signed int *__restrict __format, ...);
    308 __attribute__ ((__nothrow__,__leaf__)) extern signed int swprintf(signed int *__restrict __s, unsigned long int __n, const signed int *__restrict __format, ...);
    309 extern signed int vfwprintf(struct _IO_FILE *__restrict __s, const signed int *__restrict __format, __builtin_va_list __arg);
    310 extern signed int vwprintf(const signed int *__restrict __format, __builtin_va_list __arg);
    311 __attribute__ ((__nothrow__,__leaf__)) extern signed int vswprintf(signed int *__restrict __s, unsigned long int __n, const signed int *__restrict __format, __builtin_va_list __arg);
    312 extern signed int fwscanf(struct _IO_FILE *__restrict __stream, const signed int *__restrict __format, ...);
    313 extern signed int wscanf(const signed int *__restrict __format, ...);
    314 __attribute__ ((__nothrow__,__leaf__)) extern signed int swscanf(const signed int *__restrict __s, const signed int *__restrict __format, ...);
    315 extern signed int fwscanf(struct _IO_FILE *__restrict __stream, const signed int *__restrict __format, ...) asm ( "" "__isoc99_fwscanf" );
    316 extern signed int wscanf(const signed int *__restrict __format, ...) asm ( "" "__isoc99_wscanf" );
    317 __attribute__ ((__nothrow__,__leaf__)) extern signed int swscanf(const signed int *__restrict __s, const signed int *__restrict __format, ...) asm ( "" "__isoc99_swscanf" );
    318 extern signed int vfwscanf(struct _IO_FILE *__restrict __s, const signed int *__restrict __format, __builtin_va_list __arg);
    319 extern signed int vwscanf(const signed int *__restrict __format, __builtin_va_list __arg);
    320 __attribute__ ((__nothrow__,__leaf__)) extern signed int vswscanf(const signed int *__restrict __s, const signed int *__restrict __format, __builtin_va_list __arg);
    321 extern signed int vfwscanf(struct _IO_FILE *__restrict __s, const signed int *__restrict __format, __builtin_va_list __arg) asm ( "" "__isoc99_vfwscanf" );
    322 extern signed int vwscanf(const signed int *__restrict __format, __builtin_va_list __arg) asm ( "" "__isoc99_vwscanf" );
    323 __attribute__ ((__nothrow__,__leaf__)) extern signed int vswscanf(const signed int *__restrict __s, const signed int *__restrict __format, __builtin_va_list __arg) asm ( "" "__isoc99_vswscanf" );
    324 extern unsigned int fgetwc(struct _IO_FILE *__stream);
    325 extern unsigned int getwc(struct _IO_FILE *__stream);
    326 extern unsigned int getwchar(void);
    327 extern unsigned int fputwc(signed int __wc, struct _IO_FILE *__stream);
    328 extern unsigned int putwc(signed int __wc, struct _IO_FILE *__stream);
    329 extern unsigned int putwchar(signed int __wc);
    330 extern signed int *fgetws(signed int *__restrict __ws, signed int __n, struct _IO_FILE *__restrict __stream);
    331 extern signed int fputws(const signed int *__restrict __ws, struct _IO_FILE *__restrict __stream);
    332 extern unsigned int ungetwc(unsigned int __wc, struct _IO_FILE *__stream);
    333 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int wcsftime(signed int *__restrict __s, unsigned long int __maxsize, const signed int *__restrict __format, const struct tm *__restrict __tp);
    334 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wmemcpy_chk(signed int *__restrict __s1, const signed int *__restrict __s2, unsigned long int __n, unsigned long int __ns1);
    335 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wmemcpy_alias(signed int *__restrict __s1, const signed int *__restrict __s2, unsigned long int __n) asm ( "" "wmemcpy" );
    336 __attribute__ ((__nothrow__,__leaf__,__warning__("wmemcpy called with length bigger than size of destination " "buffer"))) extern signed int *__wmemcpy_chk_warn(signed int *__restrict __s1, const signed int *__restrict __s2, unsigned long int __n, unsigned long int __ns1) asm ( "" "__wmemcpy_chk" );
    337 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wmemcpy(signed int *__restrict __s1, const signed int *__restrict __s2, unsigned long int __n){
    338     __attribute__ ((unused)) signed int *___retval_wmemcpy__Pi_1;
    339     if ( ((signed int )((__builtin_object_size(((const void *)__s1), ((signed int )0))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    340         if ( ((signed int )((!__builtin_constant_p(__n))!=((signed int )0))) ) {
    341             signed int *_tmp_cp_ret4;
    342             ((void)(___retval_wmemcpy__Pi_1=(((void)(_tmp_cp_ret4=__wmemcpy_chk(__s1, __s2, __n, (__builtin_object_size(((const void *)__s1), ((signed int )0))/sizeof(signed int ))))) , _tmp_cp_ret4)) /* ?{} */);
    343             ((void)(_tmp_cp_ret4) /* ^?{} */);
    344             return ((signed int *)___retval_wmemcpy__Pi_1);
    345         }
    346 
    347         if ( ((signed int )((__n>(__builtin_object_size(((const void *)__s1), ((signed int )0))/sizeof(signed int )))!=((signed int )0))) ) {
    348             signed int *_tmp_cp_ret5;
    349             ((void)(___retval_wmemcpy__Pi_1=(((void)(_tmp_cp_ret5=__wmemcpy_chk_warn(__s1, __s2, __n, (__builtin_object_size(((const void *)__s1), ((signed int )0))/sizeof(signed int ))))) , _tmp_cp_ret5)) /* ?{} */);
    350             ((void)(_tmp_cp_ret5) /* ^?{} */);
    351             return ((signed int *)___retval_wmemcpy__Pi_1);
    352         }
    353 
    354     }
    355 
    356     signed int *_tmp_cp_ret6;
    357     ((void)(___retval_wmemcpy__Pi_1=(((void)(_tmp_cp_ret6=__wmemcpy_alias(__s1, __s2, __n))) , _tmp_cp_ret6)) /* ?{} */);
    358     ((void)(_tmp_cp_ret6) /* ^?{} */);
    359     return ((signed int *)___retval_wmemcpy__Pi_1);
    360 }
    361 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wmemmove_chk(signed int *__s1, const signed int *__s2, unsigned long int __n, unsigned long int __ns1);
    362 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wmemmove_alias(signed int *__s1, const signed int *__s2, unsigned long int __n) asm ( "" "wmemmove" );
    363 __attribute__ ((__nothrow__,__leaf__,__warning__("wmemmove called with length bigger than size of destination " "buffer"))) extern signed int *__wmemmove_chk_warn(signed int *__s1, const signed int *__s2, unsigned long int __n, unsigned long int __ns1) asm ( "" "__wmemmove_chk" );
    364 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wmemmove(signed int *__s1, const signed int *__s2, unsigned long int __n){
    365     __attribute__ ((unused)) signed int *___retval_wmemmove__Pi_1;
    366     if ( ((signed int )((__builtin_object_size(((const void *)__s1), ((signed int )0))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    367         if ( ((signed int )((!__builtin_constant_p(__n))!=((signed int )0))) ) {
    368             signed int *_tmp_cp_ret7;
    369             ((void)(___retval_wmemmove__Pi_1=(((void)(_tmp_cp_ret7=__wmemmove_chk(__s1, __s2, __n, (__builtin_object_size(((const void *)__s1), ((signed int )0))/sizeof(signed int ))))) , _tmp_cp_ret7)) /* ?{} */);
    370             ((void)(_tmp_cp_ret7) /* ^?{} */);
    371             return ((signed int *)___retval_wmemmove__Pi_1);
    372         }
    373 
    374         if ( ((signed int )((__n>(__builtin_object_size(((const void *)__s1), ((signed int )0))/sizeof(signed int )))!=((signed int )0))) ) {
    375             signed int *_tmp_cp_ret8;
    376             ((void)(___retval_wmemmove__Pi_1=(((void)(_tmp_cp_ret8=__wmemmove_chk_warn(__s1, __s2, __n, (__builtin_object_size(((const void *)__s1), ((signed int )0))/sizeof(signed int ))))) , _tmp_cp_ret8)) /* ?{} */);
    377             ((void)(_tmp_cp_ret8) /* ^?{} */);
    378             return ((signed int *)___retval_wmemmove__Pi_1);
    379         }
    380 
    381     }
    382 
    383     signed int *_tmp_cp_ret9;
    384     ((void)(___retval_wmemmove__Pi_1=(((void)(_tmp_cp_ret9=__wmemmove_alias(__s1, __s2, __n))) , _tmp_cp_ret9)) /* ?{} */);
    385     ((void)(_tmp_cp_ret9) /* ^?{} */);
    386     return ((signed int *)___retval_wmemmove__Pi_1);
    387 }
    388 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wmemset_chk(signed int *__s, signed int __c, unsigned long int __n, unsigned long int __ns);
    389 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wmemset_alias(signed int *__s, signed int __c, unsigned long int __n) asm ( "" "wmemset" );
    390 __attribute__ ((__nothrow__,__leaf__,__warning__("wmemset called with length bigger than size of destination " "buffer"))) extern signed int *__wmemset_chk_warn(signed int *__s, signed int __c, unsigned long int __n, unsigned long int __ns) asm ( "" "__wmemset_chk" );
    391 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wmemset(signed int *__s, signed int __c, unsigned long int __n){
    392     __attribute__ ((unused)) signed int *___retval_wmemset__Pi_1;
    393     if ( ((signed int )((__builtin_object_size(((const void *)__s), ((signed int )0))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    394         if ( ((signed int )((!__builtin_constant_p(__n))!=((signed int )0))) ) {
    395             signed int *_tmp_cp_ret10;
    396             ((void)(___retval_wmemset__Pi_1=(((void)(_tmp_cp_ret10=__wmemset_chk(__s, __c, __n, (__builtin_object_size(((const void *)__s), ((signed int )0))/sizeof(signed int ))))) , _tmp_cp_ret10)) /* ?{} */);
    397             ((void)(_tmp_cp_ret10) /* ^?{} */);
    398             return ((signed int *)___retval_wmemset__Pi_1);
    399         }
    400 
    401         if ( ((signed int )((__n>(__builtin_object_size(((const void *)__s), ((signed int )0))/sizeof(signed int )))!=((signed int )0))) ) {
    402             signed int *_tmp_cp_ret11;
    403             ((void)(___retval_wmemset__Pi_1=(((void)(_tmp_cp_ret11=__wmemset_chk_warn(__s, __c, __n, (__builtin_object_size(((const void *)__s), ((signed int )0))/sizeof(signed int ))))) , _tmp_cp_ret11)) /* ?{} */);
    404             ((void)(_tmp_cp_ret11) /* ^?{} */);
    405             return ((signed int *)___retval_wmemset__Pi_1);
    406         }
    407 
    408     }
    409 
    410     signed int *_tmp_cp_ret12;
    411     ((void)(___retval_wmemset__Pi_1=(((void)(_tmp_cp_ret12=__wmemset_alias(__s, __c, __n))) , _tmp_cp_ret12)) /* ?{} */);
    412     ((void)(_tmp_cp_ret12) /* ^?{} */);
    413     return ((signed int *)___retval_wmemset__Pi_1);
    414 }
    415 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcscpy_chk(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n);
    416 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcscpy_alias(signed int *__restrict __dest, const signed int *__restrict __src) asm ( "" "wcscpy" );
    417 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wcscpy(signed int *__restrict __dest, const signed int *__restrict __src){
    418     __attribute__ ((unused)) signed int *___retval_wcscpy__Pi_1;
    419     if ( ((signed int )((__builtin_object_size(((const void *)__dest), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    420         signed int *_tmp_cp_ret13;
    421         ((void)(___retval_wcscpy__Pi_1=(((void)(_tmp_cp_ret13=__wcscpy_chk(__dest, __src, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret13)) /* ?{} */);
    422         ((void)(_tmp_cp_ret13) /* ^?{} */);
    423         return ((signed int *)___retval_wcscpy__Pi_1);
    424     }
    425 
    426     signed int *_tmp_cp_ret14;
    427     ((void)(___retval_wcscpy__Pi_1=(((void)(_tmp_cp_ret14=__wcscpy_alias(__dest, __src))) , _tmp_cp_ret14)) /* ?{} */);
    428     ((void)(_tmp_cp_ret14) /* ^?{} */);
    429     return ((signed int *)___retval_wcscpy__Pi_1);
    430 }
    431 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcpcpy_chk(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __destlen);
    432 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcpcpy_alias(signed int *__restrict __dest, const signed int *__restrict __src) asm ( "" "wcpcpy" );
    433 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wcpcpy(signed int *__restrict __dest, const signed int *__restrict __src){
    434     __attribute__ ((unused)) signed int *___retval_wcpcpy__Pi_1;
    435     if ( ((signed int )((__builtin_object_size(((const void *)__dest), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    436         signed int *_tmp_cp_ret15;
    437         ((void)(___retval_wcpcpy__Pi_1=(((void)(_tmp_cp_ret15=__wcpcpy_chk(__dest, __src, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret15)) /* ?{} */);
    438         ((void)(_tmp_cp_ret15) /* ^?{} */);
    439         return ((signed int *)___retval_wcpcpy__Pi_1);
    440     }
    441 
    442     signed int *_tmp_cp_ret16;
    443     ((void)(___retval_wcpcpy__Pi_1=(((void)(_tmp_cp_ret16=__wcpcpy_alias(__dest, __src))) , _tmp_cp_ret16)) /* ?{} */);
    444     ((void)(_tmp_cp_ret16) /* ^?{} */);
    445     return ((signed int *)___retval_wcpcpy__Pi_1);
    446 }
    447 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcsncpy_chk(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n, unsigned long int __destlen);
    448 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcsncpy_alias(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n) asm ( "" "wcsncpy" );
    449 __attribute__ ((__nothrow__,__leaf__,__warning__("wcsncpy called with length bigger than size of destination " "buffer"))) extern signed int *__wcsncpy_chk_warn(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n, unsigned long int __destlen) asm ( "" "__wcsncpy_chk" );
    450 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wcsncpy(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n){
    451     __attribute__ ((unused)) signed int *___retval_wcsncpy__Pi_1;
    452     if ( ((signed int )((__builtin_object_size(((const void *)__dest), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    453         if ( ((signed int )((!__builtin_constant_p(__n))!=((signed int )0))) ) {
    454             signed int *_tmp_cp_ret17;
    455             ((void)(___retval_wcsncpy__Pi_1=(((void)(_tmp_cp_ret17=__wcsncpy_chk(__dest, __src, __n, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret17)) /* ?{} */);
    456             ((void)(_tmp_cp_ret17) /* ^?{} */);
    457             return ((signed int *)___retval_wcsncpy__Pi_1);
    458         }
    459 
    460         if ( ((signed int )((__n>(__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int )))!=((signed int )0))) ) {
    461             signed int *_tmp_cp_ret18;
    462             ((void)(___retval_wcsncpy__Pi_1=(((void)(_tmp_cp_ret18=__wcsncpy_chk_warn(__dest, __src, __n, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret18)) /* ?{} */);
    463             ((void)(_tmp_cp_ret18) /* ^?{} */);
    464             return ((signed int *)___retval_wcsncpy__Pi_1);
    465         }
    466 
    467     }
    468 
    469     signed int *_tmp_cp_ret19;
    470     ((void)(___retval_wcsncpy__Pi_1=(((void)(_tmp_cp_ret19=__wcsncpy_alias(__dest, __src, __n))) , _tmp_cp_ret19)) /* ?{} */);
    471     ((void)(_tmp_cp_ret19) /* ^?{} */);
    472     return ((signed int *)___retval_wcsncpy__Pi_1);
    473 }
    474 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcpncpy_chk(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n, unsigned long int __destlen);
    475 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcpncpy_alias(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n) asm ( "" "wcpncpy" );
    476 __attribute__ ((__nothrow__,__leaf__,__warning__("wcpncpy called with length bigger than size of destination " "buffer"))) extern signed int *__wcpncpy_chk_warn(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n, unsigned long int __destlen) asm ( "" "__wcpncpy_chk" );
    477 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wcpncpy(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n){
    478     __attribute__ ((unused)) signed int *___retval_wcpncpy__Pi_1;
    479     if ( ((signed int )((__builtin_object_size(((const void *)__dest), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    480         if ( ((signed int )((!__builtin_constant_p(__n))!=((signed int )0))) ) {
    481             signed int *_tmp_cp_ret20;
    482             ((void)(___retval_wcpncpy__Pi_1=(((void)(_tmp_cp_ret20=__wcpncpy_chk(__dest, __src, __n, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret20)) /* ?{} */);
    483             ((void)(_tmp_cp_ret20) /* ^?{} */);
    484             return ((signed int *)___retval_wcpncpy__Pi_1);
    485         }
    486 
    487         if ( ((signed int )((__n>(__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int )))!=((signed int )0))) ) {
    488             signed int *_tmp_cp_ret21;
    489             ((void)(___retval_wcpncpy__Pi_1=(((void)(_tmp_cp_ret21=__wcpncpy_chk_warn(__dest, __src, __n, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret21)) /* ?{} */);
    490             ((void)(_tmp_cp_ret21) /* ^?{} */);
    491             return ((signed int *)___retval_wcpncpy__Pi_1);
    492         }
    493 
    494     }
    495 
    496     signed int *_tmp_cp_ret22;
    497     ((void)(___retval_wcpncpy__Pi_1=(((void)(_tmp_cp_ret22=__wcpncpy_alias(__dest, __src, __n))) , _tmp_cp_ret22)) /* ?{} */);
    498     ((void)(_tmp_cp_ret22) /* ^?{} */);
    499     return ((signed int *)___retval_wcpncpy__Pi_1);
    500 }
    501 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcscat_chk(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __destlen);
    502 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcscat_alias(signed int *__restrict __dest, const signed int *__restrict __src) asm ( "" "wcscat" );
    503 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wcscat(signed int *__restrict __dest, const signed int *__restrict __src){
    504     __attribute__ ((unused)) signed int *___retval_wcscat__Pi_1;
    505     if ( ((signed int )((__builtin_object_size(((const void *)__dest), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    506         signed int *_tmp_cp_ret23;
    507         ((void)(___retval_wcscat__Pi_1=(((void)(_tmp_cp_ret23=__wcscat_chk(__dest, __src, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret23)) /* ?{} */);
    508         ((void)(_tmp_cp_ret23) /* ^?{} */);
    509         return ((signed int *)___retval_wcscat__Pi_1);
    510     }
    511 
    512     signed int *_tmp_cp_ret24;
    513     ((void)(___retval_wcscat__Pi_1=(((void)(_tmp_cp_ret24=__wcscat_alias(__dest, __src))) , _tmp_cp_ret24)) /* ?{} */);
    514     ((void)(_tmp_cp_ret24) /* ^?{} */);
    515     return ((signed int *)___retval_wcscat__Pi_1);
    516 }
    517 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcsncat_chk(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n, unsigned long int __destlen);
    518 __attribute__ ((__nothrow__,__leaf__)) extern signed int *__wcsncat_alias(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n) asm ( "" "wcsncat" );
    519 __attribute__ ((__artificial__,__always_inline__,__nothrow__,__leaf__)) extern inline signed int *wcsncat(signed int *__restrict __dest, const signed int *__restrict __src, unsigned long int __n){
    520     __attribute__ ((unused)) signed int *___retval_wcsncat__Pi_1;
    521     if ( ((signed int )((__builtin_object_size(((const void *)__dest), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    522         signed int *_tmp_cp_ret25;
    523         ((void)(___retval_wcsncat__Pi_1=(((void)(_tmp_cp_ret25=__wcsncat_chk(__dest, __src, __n, (__builtin_object_size(((const void *)__dest), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret25)) /* ?{} */);
    524         ((void)(_tmp_cp_ret25) /* ^?{} */);
    525         return ((signed int *)___retval_wcsncat__Pi_1);
    526     }
    527 
    528     signed int *_tmp_cp_ret26;
    529     ((void)(___retval_wcsncat__Pi_1=(((void)(_tmp_cp_ret26=__wcsncat_alias(__dest, __src, __n))) , _tmp_cp_ret26)) /* ?{} */);
    530     ((void)(_tmp_cp_ret26) /* ^?{} */);
    531     return ((signed int *)___retval_wcsncat__Pi_1);
    532 }
    533 __attribute__ ((__nothrow__,__leaf__)) extern signed int __swprintf_chk(signed int *__restrict __s, unsigned long int __n, signed int __flag, unsigned long int __s_len, const signed int *__restrict __format, ...);
    534 __attribute__ ((__nothrow__,__leaf__)) extern signed int __swprintf_alias(signed int *__restrict __s, unsigned long int __n, const signed int *__restrict __fmt, ...) asm ( "" "swprintf" );
    535 __attribute__ ((__nothrow__,__leaf__,__artificial__,__always_inline__)) extern inline signed int swprintf(signed int *__restrict __s, unsigned long int __n, const signed int *__restrict __fmt, ...){
    536     __attribute__ ((unused)) signed int ___retval_swprintf__i_1;
    537     if ( ((signed int )((((signed int )((__builtin_object_size(((const void *)__s), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) || ((signed int )((2>((signed int )1))!=((signed int )0))))!=((signed int )0))) ) {
    538         signed int _tmp_cp_ret27;
    539         ((void)(___retval_swprintf__i_1=(((void)(_tmp_cp_ret27=__swprintf_chk(__s, __n, (2-((signed int )1)), (__builtin_object_size(((const void *)__s), (2>((signed int )1)))/sizeof(signed int )), __fmt, __builtin_va_arg_pack()))) , _tmp_cp_ret27)) /* ?{} */);
    540         ((void)(_tmp_cp_ret27) /* ^?{} */);
    541         return ((signed int )___retval_swprintf__i_1);
    542     }
    543 
    544     signed int _tmp_cp_ret28;
    545     ((void)(___retval_swprintf__i_1=(((void)(_tmp_cp_ret28=__swprintf_alias(__s, __n, __fmt, __builtin_va_arg_pack()))) , _tmp_cp_ret28)) /* ?{} */);
    546     ((void)(_tmp_cp_ret28) /* ^?{} */);
    547     return ((signed int )___retval_swprintf__i_1);
    548 }
    549 __attribute__ ((__nothrow__,__leaf__)) extern signed int __vswprintf_chk(signed int *__restrict __s, unsigned long int __n, signed int __flag, unsigned long int __s_len, const signed int *__restrict __format, __builtin_va_list __arg);
    550 __attribute__ ((__nothrow__,__leaf__)) extern signed int __vswprintf_alias(signed int *__restrict __s, unsigned long int __n, const signed int *__restrict __fmt, __builtin_va_list __ap) asm ( "" "vswprintf" );
    551 __attribute__ ((__nothrow__,__leaf__,__artificial__,__always_inline__)) extern inline signed int vswprintf(signed int *__restrict __s, unsigned long int __n, const signed int *__restrict __fmt, __builtin_va_list __ap){
    552     __attribute__ ((unused)) signed int ___retval_vswprintf__i_1;
    553     if ( ((signed int )((((signed int )((__builtin_object_size(((const void *)__s), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) || ((signed int )((2>((signed int )1))!=((signed int )0))))!=((signed int )0))) ) {
    554         signed int _tmp_cp_ret29;
    555         ((void)(___retval_vswprintf__i_1=(((void)(_tmp_cp_ret29=__vswprintf_chk(__s, __n, (2-((signed int )1)), (__builtin_object_size(((const void *)__s), (2>((signed int )1)))/sizeof(signed int )), __fmt, __ap))) , _tmp_cp_ret29)) /* ?{} */);
    556         ((void)(_tmp_cp_ret29) /* ^?{} */);
    557         return ((signed int )___retval_vswprintf__i_1);
    558     }
    559 
    560     signed int _tmp_cp_ret30;
    561     ((void)(___retval_vswprintf__i_1=(((void)(_tmp_cp_ret30=__vswprintf_alias(__s, __n, __fmt, __ap))) , _tmp_cp_ret30)) /* ?{} */);
    562     ((void)(_tmp_cp_ret30) /* ^?{} */);
    563     return ((signed int )___retval_vswprintf__i_1);
    564 }
    565 extern signed int __fwprintf_chk(struct _IO_FILE *__restrict __stream, signed int __flag, const signed int *__restrict __format, ...);
    566 extern signed int __wprintf_chk(signed int __flag, const signed int *__restrict __format, ...);
    567 extern signed int __vfwprintf_chk(struct _IO_FILE *__restrict __stream, signed int __flag, const signed int *__restrict __format, __builtin_va_list __ap);
    568 extern signed int __vwprintf_chk(signed int __flag, const signed int *__restrict __format, __builtin_va_list __ap);
    569 __attribute__ ((__artificial__,__always_inline__)) extern inline signed int wprintf(const signed int *__restrict __fmt, ...){
    570     __attribute__ ((unused)) signed int ___retval_wprintf__i_1;
    571     signed int _tmp_cp_ret31;
    572     ((void)(___retval_wprintf__i_1=(((void)(_tmp_cp_ret31=__wprintf_chk((2-((signed int )1)), __fmt, __builtin_va_arg_pack()))) , _tmp_cp_ret31)) /* ?{} */);
    573     ((void)(_tmp_cp_ret31) /* ^?{} */);
    574     return ((signed int )___retval_wprintf__i_1);
    575 }
    576 __attribute__ ((__artificial__,__always_inline__)) extern inline signed int fwprintf(struct _IO_FILE *__restrict __stream, const signed int *__restrict __fmt, ...){
    577     __attribute__ ((unused)) signed int ___retval_fwprintf__i_1;
    578     signed int _tmp_cp_ret32;
    579     ((void)(___retval_fwprintf__i_1=(((void)(_tmp_cp_ret32=__fwprintf_chk(__stream, (2-((signed int )1)), __fmt, __builtin_va_arg_pack()))) , _tmp_cp_ret32)) /* ?{} */);
    580     ((void)(_tmp_cp_ret32) /* ^?{} */);
    581     return ((signed int )___retval_fwprintf__i_1);
    582 }
    583 __attribute__ ((__artificial__,__always_inline__)) extern inline signed int vwprintf(const signed int *__restrict __fmt, __builtin_va_list __ap){
    584     __attribute__ ((unused)) signed int ___retval_vwprintf__i_1;
    585     signed int _tmp_cp_ret33;
    586     ((void)(___retval_vwprintf__i_1=(((void)(_tmp_cp_ret33=__vwprintf_chk((2-((signed int )1)), __fmt, __ap))) , _tmp_cp_ret33)) /* ?{} */);
    587     ((void)(_tmp_cp_ret33) /* ^?{} */);
    588     return ((signed int )___retval_vwprintf__i_1);
    589 }
    590 __attribute__ ((__artificial__,__always_inline__)) extern inline signed int vfwprintf(struct _IO_FILE *__restrict __stream, const signed int *__restrict __fmt, __builtin_va_list __ap){
    591     __attribute__ ((unused)) signed int ___retval_vfwprintf__i_1;
    592     signed int _tmp_cp_ret34;
    593     ((void)(___retval_vfwprintf__i_1=(((void)(_tmp_cp_ret34=__vfwprintf_chk(__stream, (2-((signed int )1)), __fmt, __ap))) , _tmp_cp_ret34)) /* ?{} */);
    594     ((void)(_tmp_cp_ret34) /* ^?{} */);
    595     return ((signed int )___retval_vfwprintf__i_1);
    596 }
    597 __attribute__ ((__warn_unused_result__)) extern signed int *__fgetws_chk(signed int *__restrict __s, unsigned long int __size, signed int __n, struct _IO_FILE *__restrict __stream);
    598 __attribute__ ((__warn_unused_result__)) extern signed int *__fgetws_alias(signed int *__restrict __s, signed int __n, struct _IO_FILE *__restrict __stream) asm ( "" "fgetws" );
    599 __attribute__ ((__warn_unused_result__,__warning__("fgetws called with bigger size than length " "of destination buffer"))) extern signed int *__fgetws_chk_warn(signed int *__restrict __s, unsigned long int __size, signed int __n, struct _IO_FILE *__restrict __stream) asm ( "" "__fgetws_chk" );
    600 __attribute__ ((__warn_unused_result__,__artificial__,__always_inline__)) extern inline signed int *fgetws(signed int *__restrict __s, signed int __n, struct _IO_FILE *__restrict __stream){
    601     __attribute__ ((unused)) signed int *___retval_fgetws__Pi_1;
    602     if ( ((signed int )((__builtin_object_size(((const void *)__s), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    603         if ( ((signed int )((((signed int )((!__builtin_constant_p(__n))!=((signed int )0))) || ((signed int )((__n<=((signed int )0))!=((signed int )0))))!=((signed int )0))) ) {
    604             signed int *_tmp_cp_ret35;
    605             ((void)(___retval_fgetws__Pi_1=(((void)(_tmp_cp_ret35=__fgetws_chk(__s, (__builtin_object_size(((const void *)__s), (2>((signed int )1)))/sizeof(signed int )), __n, __stream))) , _tmp_cp_ret35)) /* ?{} */);
    606             ((void)(_tmp_cp_ret35) /* ^?{} */);
    607             return ((signed int *)___retval_fgetws__Pi_1);
    608         }
    609 
    610         if ( ((signed int )((((unsigned long int )__n)>(__builtin_object_size(((const void *)__s), (2>((signed int )1)))/sizeof(signed int )))!=((signed int )0))) ) {
    611             signed int *_tmp_cp_ret36;
    612             ((void)(___retval_fgetws__Pi_1=(((void)(_tmp_cp_ret36=__fgetws_chk_warn(__s, (__builtin_object_size(((const void *)__s), (2>((signed int )1)))/sizeof(signed int )), __n, __stream))) , _tmp_cp_ret36)) /* ?{} */);
    613             ((void)(_tmp_cp_ret36) /* ^?{} */);
    614             return ((signed int *)___retval_fgetws__Pi_1);
    615         }
    616 
    617     }
    618 
    619     signed int *_tmp_cp_ret37;
    620     ((void)(___retval_fgetws__Pi_1=(((void)(_tmp_cp_ret37=__fgetws_alias(__s, __n, __stream))) , _tmp_cp_ret37)) /* ?{} */);
    621     ((void)(_tmp_cp_ret37) /* ^?{} */);
    622     return ((signed int *)___retval_fgetws__Pi_1);
    623 }
    624 __attribute__ ((__nothrow__,__leaf__,__warn_unused_result__)) extern unsigned long int __wcrtomb_chk(char *__restrict __s, signed int __wchar, struct __anonymous1 *__restrict __p, unsigned long int __buflen);
    625 __attribute__ ((__nothrow__,__leaf__,__warn_unused_result__)) extern unsigned long int __wcrtomb_alias(char *__restrict __s, signed int __wchar, struct __anonymous1 *__restrict __ps) asm ( "" "wcrtomb" );
    626 __attribute__ ((__nothrow__,__leaf__,__warn_unused_result__,__artificial__,__always_inline__)) extern inline unsigned long int wcrtomb(char *__restrict __s, signed int __wchar, struct __anonymous1 *__restrict __ps){
    627     __attribute__ ((unused)) unsigned long int ___retval_wcrtomb__Ul_1;
    628     if ( ((signed int )((((signed int )((__builtin_object_size(((const void *)__s), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) && ((signed int )((((unsigned long int )16)>__builtin_object_size(((const void *)__s), (2>((signed int )1))))!=((signed int )0))))!=((signed int )0))) ) {
    629         unsigned long int _tmp_cp_ret38;
    630         ((void)(___retval_wcrtomb__Ul_1=(((void)(_tmp_cp_ret38=__wcrtomb_chk(__s, __wchar, __ps, __builtin_object_size(((const void *)__s), (2>((signed int )1)))))) , _tmp_cp_ret38)) /* ?{} */);
    631         ((void)(_tmp_cp_ret38) /* ^?{} */);
    632         return ((unsigned long int )___retval_wcrtomb__Ul_1);
    633     }
    634 
    635     unsigned long int _tmp_cp_ret39;
    636     ((void)(___retval_wcrtomb__Ul_1=(((void)(_tmp_cp_ret39=__wcrtomb_alias(__s, __wchar, __ps))) , _tmp_cp_ret39)) /* ?{} */);
    637     ((void)(_tmp_cp_ret39) /* ^?{} */);
    638     return ((unsigned long int )___retval_wcrtomb__Ul_1);
    639 }
    640 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int __mbsrtowcs_chk(signed int *__restrict __dst, const char **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps, unsigned long int __dstlen);
    641 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int __mbsrtowcs_alias(signed int *__restrict __dst, const char **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps) asm ( "" "mbsrtowcs" );
    642 __attribute__ ((__nothrow__,__leaf__,__warning__("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)"))) extern unsigned long int __mbsrtowcs_chk_warn(signed int *__restrict __dst, const char **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps, unsigned long int __dstlen) asm ( "" "__mbsrtowcs_chk" );
    643 __attribute__ ((__nothrow__,__leaf__,__artificial__,__always_inline__)) extern inline unsigned long int mbsrtowcs(signed int *__restrict __dst, const char **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps){
    644     __attribute__ ((unused)) unsigned long int ___retval_mbsrtowcs__Ul_1;
    645     if ( ((signed int )((__builtin_object_size(((const void *)__dst), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    646         if ( ((signed int )((!__builtin_constant_p(__len))!=((signed int )0))) ) {
    647             unsigned long int _tmp_cp_ret40;
    648             ((void)(___retval_mbsrtowcs__Ul_1=(((void)(_tmp_cp_ret40=__mbsrtowcs_chk(__dst, __src, __len, __ps, (__builtin_object_size(((const void *)__dst), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret40)) /* ?{} */);
    649             ((void)(_tmp_cp_ret40) /* ^?{} */);
    650             return ((unsigned long int )___retval_mbsrtowcs__Ul_1);
    651         }
    652 
    653         if ( ((signed int )((__len>(__builtin_object_size(((const void *)__dst), (2>((signed int )1)))/sizeof(signed int )))!=((signed int )0))) ) {
    654             unsigned long int _tmp_cp_ret41;
    655             ((void)(___retval_mbsrtowcs__Ul_1=(((void)(_tmp_cp_ret41=__mbsrtowcs_chk_warn(__dst, __src, __len, __ps, (__builtin_object_size(((const void *)__dst), (2>((signed int )1)))/sizeof(signed int ))))) , _tmp_cp_ret41)) /* ?{} */);
    656             ((void)(_tmp_cp_ret41) /* ^?{} */);
    657             return ((unsigned long int )___retval_mbsrtowcs__Ul_1);
    658         }
    659 
    660     }
    661 
    662     unsigned long int _tmp_cp_ret42;
    663     ((void)(___retval_mbsrtowcs__Ul_1=(((void)(_tmp_cp_ret42=__mbsrtowcs_alias(__dst, __src, __len, __ps))) , _tmp_cp_ret42)) /* ?{} */);
    664     ((void)(_tmp_cp_ret42) /* ^?{} */);
    665     return ((unsigned long int )___retval_mbsrtowcs__Ul_1);
    666 }
    667 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int __wcsrtombs_chk(char *__restrict __dst, const signed int **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps, unsigned long int __dstlen);
    668 __attribute__ ((__nothrow__,__leaf__)) extern unsigned long int __wcsrtombs_alias(char *__restrict __dst, const signed int **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps) asm ( "" "wcsrtombs" );
    669 __attribute__ ((__nothrow__,__leaf__,__warning__("wcsrtombs called with dst buffer smaller than len"))) extern unsigned long int __wcsrtombs_chk_warn(char *__restrict __dst, const signed int **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps, unsigned long int __dstlen) asm ( "" "__wcsrtombs_chk" );
    670 __attribute__ ((__nothrow__,__leaf__,__artificial__,__always_inline__)) extern inline unsigned long int wcsrtombs(char *__restrict __dst, const signed int **__restrict __src, unsigned long int __len, struct __anonymous1 *__restrict __ps){
    671     __attribute__ ((unused)) unsigned long int ___retval_wcsrtombs__Ul_1;
    672     if ( ((signed int )((__builtin_object_size(((const void *)__dst), (2>((signed int )1)))!=((unsigned long int )(-((signed int )1))))!=((signed int )0))) ) {
    673         if ( ((signed int )((!__builtin_constant_p(__len))!=((signed int )0))) ) {
    674             unsigned long int _tmp_cp_ret43;
    675             ((void)(___retval_wcsrtombs__Ul_1=(((void)(_tmp_cp_ret43=__wcsrtombs_chk(__dst, __src, __len, __ps, __builtin_object_size(((const void *)__dst), (2>((signed int )1)))))) , _tmp_cp_ret43)) /* ?{} */);
    676             ((void)(_tmp_cp_ret43) /* ^?{} */);
    677             return ((unsigned long int )___retval_wcsrtombs__Ul_1);
    678         }
    679 
    680         if ( ((signed int )((__len>__builtin_object_size(((const void *)__dst), (2>((signed int )1))))!=((signed int )0))) ) {
    681             unsigned long int _tmp_cp_ret44;
    682             ((void)(___retval_wcsrtombs__Ul_1=(((void)(_tmp_cp_ret44=__wcsrtombs_chk_warn(__dst, __src, __len, __ps, __builtin_object_size(((const void *)__dst), (2>((signed int )1)))))) , _tmp_cp_ret44)) /* ?{} */);
    683             ((void)(_tmp_cp_ret44) /* ^?{} */);
    684             return ((unsigned long int )___retval_wcsrtombs__Ul_1);
    685         }
    686 
    687     }
    688 
    689     unsigned long int _tmp_cp_ret45;
    690     ((void)(___retval_wcsrtombs__Ul_1=(((void)(_tmp_cp_ret45=__wcsrtombs_alias(__dst, __src, __len, __ps))) , _tmp_cp_ret45)) /* ?{} */);
    691     ((void)(_tmp_cp_ret45) /* ^?{} */);
    692     return ((unsigned long int )___retval_wcsrtombs__Ul_1);
    693 }
    6947void __for_each__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
    6958void __for_each_reverse__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
     
    808121struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1283, signed int __size__i_1);
    809122void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1285), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
    810 enum __anonymous2 {
    811     __sepSize__C13e__anonymous2_1 = ((signed int )16),
     123enum __anonymous0 {
     124    __sepSize__C13e__anonymous0_1 = ((signed int )16),
    812125};
    813126struct ofstream {
     
    817130    _Bool __sawNL__b_1;
    818131    const char *__sepCur__PCc_1;
    819     char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous2_1)];
    820     char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous2_1)];
     132    char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)];
     133    char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)];
    821134};
    822135static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
     
    831144    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    832145    {
    833         signed int _index18 = ((signed int )0);
    834         for (;(_index18<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index18))) {
    835             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)])))) /* ?{} */);
    836         }
    837 
    838     }
    839     {
    840         signed int _index19 = ((signed int )0);
    841         for (;(_index19<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index19))) {
    842             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)])))) /* ?{} */);
     146        signed int _index0 = ((signed int )0);
     147        for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
     148            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index0)])))) /* ?{} */);
     149        }
     150
     151    }
     152    {
     153        signed int _index1 = ((signed int )0);
     154        for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
     155            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index1)])))) /* ?{} */);
    843156        }
    844157
     
    852165    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
    853166    {
    854         signed int _index20 = ((signed int )0);
    855         for (;(_index20<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index20))) {
    856             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)])))=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
    857         }
    858 
    859     }
    860     {
    861         signed int _index21 = ((signed int )0);
    862         for (;(_index21<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index21))) {
    863             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)])))=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
     167        signed int _index2 = ((signed int )0);
     168        for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
     169            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index2)])))=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
     170        }
     171
     172    }
     173    {
     174        signed int _index3 = ((signed int )0);
     175        for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
     176            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index3)])))=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index3)]) /* ?{} */);
    864177        }
    865178
     
    868181static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
    869182    {
    870         signed int _index22 = ((signed int )(((signed int )__sepSize__C13e__anonymous2_1)-1));
    871         for (;(_index22>=0);((void)(--_index22))) {
    872             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index22)])))) /* ^?{} */);
    873         }
    874 
    875     }
    876     {
    877         signed int _index23 = ((signed int )(((signed int )__sepSize__C13e__anonymous2_1)-1));
    878         for (;(_index23>=0);((void)(--_index23))) {
    879             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index23)])))) /* ^?{} */);
     183        signed int _index4 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
     184        for (;(_index4>=0);((void)(--_index4))) {
     185            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)])))) /* ^?{} */);
     186        }
     187
     188    }
     189    {
     190        signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
     191        for (;(_index5>=0);((void)(--_index5))) {
     192            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index5)])))) /* ^?{} */);
    880193        }
    881194
     
    895208    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
    896209    {
    897         signed int _index24 = ((signed int )0);
    898         for (;(_index24<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index24))) {
    899             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index24)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index24)]));
    900         }
    901 
    902     }
    903 
    904     {
    905         signed int _index25 = ((signed int )0);
    906         for (;(_index25<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index25))) {
    907             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index25)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index25)]));
     210        signed int _index6 = ((signed int )0);
     211        for (;(_index6<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index6))) {
     212            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index6)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index6)]));
     213        }
     214
     215    }
     216
     217    {
     218        signed int _index7 = ((signed int )0);
     219        for (;(_index7<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index7))) {
     220            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index7)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index7)]));
    908221        }
    909222
     
    920233    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    921234    {
    922         signed int _index26 = ((signed int )0);
    923         for (;(_index26<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index26))) {
    924             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index26)])))) /* ?{} */);
    925         }
    926 
    927     }
    928     {
    929         signed int _index27 = ((signed int )0);
    930         for (;(_index27<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index27))) {
    931             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index27)])))) /* ?{} */);
     235        signed int _index8 = ((signed int )0);
     236        for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
     237            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index8)])))) /* ?{} */);
     238        }
     239
     240    }
     241    {
     242        signed int _index9 = ((signed int )0);
     243        for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
     244            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index9)])))) /* ?{} */);
    932245        }
    933246
     
    941254    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    942255    {
    943         signed int _index28 = ((signed int )0);
    944         for (;(_index28<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index28))) {
    945             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index28)])))) /* ?{} */);
    946         }
    947 
    948     }
    949     {
    950         signed int _index29 = ((signed int )0);
    951         for (;(_index29<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index29))) {
    952             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index29)])))) /* ?{} */);
     256        signed int _index10 = ((signed int )0);
     257        for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
     258            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index10)])))) /* ?{} */);
     259        }
     260
     261    }
     262    {
     263        signed int _index11 = ((signed int )0);
     264        for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
     265            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index11)])))) /* ?{} */);
    953266        }
    954267
     
    962275    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    963276    {
    964         signed int _index30 = ((signed int )0);
    965         for (;(_index30<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index30))) {
    966             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index30)])))) /* ?{} */);
    967         }
    968 
    969     }
    970     {
    971         signed int _index31 = ((signed int )0);
    972         for (;(_index31<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index31))) {
    973             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index31)])))) /* ?{} */);
     277        signed int _index12 = ((signed int )0);
     278        for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
     279            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index12)])))) /* ?{} */);
     280        }
     281
     282    }
     283    {
     284        signed int _index13 = ((signed int )0);
     285        for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
     286            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index13)])))) /* ?{} */);
    974287        }
    975288
     
    983296    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
    984297    {
    985         signed int _index32 = ((signed int )0);
    986         for (;(_index32<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index32))) {
    987             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index32)])))) /* ?{} */);
    988         }
    989 
    990     }
    991     {
    992         signed int _index33 = ((signed int )0);
    993         for (;(_index33<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index33))) {
    994             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index33)])))) /* ?{} */);
     298        signed int _index14 = ((signed int )0);
     299        for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
     300            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index14)])))) /* ?{} */);
     301        }
     302
     303    }
     304    {
     305        signed int _index15 = ((signed int )0);
     306        for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
     307            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index15)])))) /* ?{} */);
    995308        }
    996309
     
    1004317    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
    1005318    {
    1006         signed int _index34 = ((signed int )0);
    1007         for (;(_index34<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index34))) {
    1008             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index34)])))) /* ?{} */);
    1009         }
    1010 
    1011     }
    1012     {
    1013         signed int _index35 = ((signed int )0);
    1014         for (;(_index35<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index35))) {
    1015             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index35)])))) /* ?{} */);
    1016         }
    1017 
    1018     }
    1019 }
    1020 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous2_1)]){
     319        signed int _index16 = ((signed int )0);
     320        for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
     321            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index16)])))) /* ?{} */);
     322        }
     323
     324    }
     325    {
     326        signed int _index17 = ((signed int )0);
     327        for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
     328            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index17)])))) /* ?{} */);
     329        }
     330
     331    }
     332}
     333static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){
    1021334    ((void)((*___dst__R9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
    1022335    ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     
    1025338    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
    1026339    {
    1027         signed int _index36 = ((signed int )0);
    1028         for (;(_index36<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index36))) {
    1029             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index36)])))=__separator__A0c_1[((signed long int )_index36)]) /* ?{} */);
    1030         }
    1031 
    1032     }
    1033     {
    1034         signed int _index37 = ((signed int )0);
    1035         for (;(_index37<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index37))) {
    1036             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index37)])))) /* ?{} */);
    1037         }
    1038 
    1039     }
    1040 }
    1041 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous2_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous2_1)]){
     340        signed int _index18 = ((signed int )0);
     341        for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
     342            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)])))=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
     343        }
     344
     345    }
     346    {
     347        signed int _index19 = ((signed int )0);
     348        for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
     349            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)])))) /* ?{} */);
     350        }
     351
     352    }
     353}
     354static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){
    1042355    ((void)((*___dst__R9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
    1043356    ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     
    1046359    ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
    1047360    {
    1048         signed int _index38 = ((signed int )0);
    1049         for (;(_index38<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index38))) {
    1050             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index38)])))=__separator__A0c_1[((signed long int )_index38)]) /* ?{} */);
    1051         }
    1052 
    1053     }
    1054     {
    1055         signed int _index39 = ((signed int )0);
    1056         for (;(_index39<((signed int )__sepSize__C13e__anonymous2_1));((void)(++_index39))) {
    1057             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index39)])))=__tupleSeparator__A0c_1[((signed long int )_index39)]) /* ?{} */);
     361        signed int _index20 = ((signed int )0);
     362        for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
     363            ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)])))=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
     364        }
     365
     366    }
     367    {
     368        signed int _index21 = ((signed int )0);
     369        for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
     370            ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)])))=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
    1058371        }
    1059372
     
    1118431extern struct ifstream *__sin__P9sifstream_1;
    1119432void __f__F_c__1(char __v__c_1){
    1120     struct ofstream *_tmp_cp_ret46;
    1121     struct ofstream *_tmp_cp_ret47;
    1122     struct ofstream *_tmp_cp_ret48;
     433    struct ofstream *_tmp_cp_ret0;
     434    struct ofstream *_tmp_cp_ret1;
     435    struct ofstream *_tmp_cp_ret2;
    1123436    __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
    1124437        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1322))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1323))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1324, _Bool __anonymous_object1325))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1326))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1327, const char *__anonymous_object1328))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1329))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1330, _Bool __anonymous_object1331))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1332))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1333))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1335))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1336))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1337, const char *__anonymous_object1338))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1339))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1340, const char *__anonymous_object1341))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1342))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1343))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1344, const char *__anonymous_object1345, unsigned long int __anonymous_object1346))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1347, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
    1125438    }
    1126     ((void)(((void)(_tmp_cp_ret48=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1348))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1349))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1350, _Bool __anonymous_object1351))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1352))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1353, const char *__anonymous_object1354))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1355))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1356, _Bool __anonymous_object1357))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1358))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1359))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1362))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1363, const char *__anonymous_object1364))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1365))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1366, const char *__anonymous_object1367))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1368))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1369))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1370, const char *__anonymous_object1371, unsigned long int __anonymous_object1372))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1373, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret47=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(((_Bool (*)(void *__anonymous_object1374))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1375))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1376, _Bool __anonymous_object1377))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1378))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1379, const char *__anonymous_object1380))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1381))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1382, _Bool __anonymous_object1383))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1384))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1385))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1388))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1389, const char *__anonymous_object1390))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1391))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1392, const char *__anonymous_object1393))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1394))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1395))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1396, const char *__anonymous_object1397, unsigned long int __anonymous_object1398))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1399, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret46=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1400))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1401))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1402, _Bool __anonymous_object1403))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1404))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1405, const char *__anonymous_object1406))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1407))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1408, _Bool __anonymous_object1409))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1410))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1411))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1414))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1415, const char *__anonymous_object1416))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1417))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1418, const char *__anonymous_object1419))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1420))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1421))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1422, const char *__anonymous_object1423, unsigned long int __anonymous_object1424))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1425, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "char "))) , _tmp_cp_ret46), __v__c_1))) , _tmp_cp_ret47), ((void *(*)(void *__anonymous_object1426))(&_thunk0))))) , _tmp_cp_ret48));
    1127     ((void)(_tmp_cp_ret46) /* ^?{} */);
    1128     ((void)(_tmp_cp_ret47) /* ^?{} */);
    1129     ((void)(_tmp_cp_ret48) /* ^?{} */);
     439    ((void)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1348))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1349))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1350, _Bool __anonymous_object1351))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1352))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1353, const char *__anonymous_object1354))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1355))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1356, _Bool __anonymous_object1357))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1358))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1359))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1362))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1363, const char *__anonymous_object1364))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1365))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1366, const char *__anonymous_object1367))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1368))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1369))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1370, const char *__anonymous_object1371, unsigned long int __anonymous_object1372))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1373, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret1=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(((_Bool (*)(void *__anonymous_object1374))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1375))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1376, _Bool __anonymous_object1377))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1378))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1379, const char *__anonymous_object1380))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1381))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1382, _Bool __anonymous_object1383))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1384))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1385))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1388))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1389, const char *__anonymous_object1390))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1391))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1392, const char *__anonymous_object1393))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1394))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1395))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1396, const char *__anonymous_object1397, unsigned long int __anonymous_object1398))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1399, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret0=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1400))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1401))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1402, _Bool __anonymous_object1403))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1404))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1405, const char *__anonymous_object1406))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1407))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1408, _Bool __anonymous_object1409))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1410))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1411))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1414))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1415, const char *__anonymous_object1416))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1417))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1418, const char *__anonymous_object1419))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1420))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1421))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1422, const char *__anonymous_object1423, unsigned long int __anonymous_object1424))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1425, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "char "))) , _tmp_cp_ret0), __v__c_1))) , _tmp_cp_ret1), ((void *(*)(void *__anonymous_object1426))(&_thunk0))))) , _tmp_cp_ret2));
     440    ((void)(_tmp_cp_ret0) /* ^?{} */);
     441    ((void)(_tmp_cp_ret1) /* ^?{} */);
     442    ((void)(_tmp_cp_ret2) /* ^?{} */);
    1130443}
    1131444void __f__F_Sc__1(signed char __v__Sc_1){
    1132     struct ofstream *_tmp_cp_ret49;
    1133     struct ofstream *_tmp_cp_ret50;
    1134     struct ofstream *_tmp_cp_ret51;
     445    struct ofstream *_tmp_cp_ret3;
     446    struct ofstream *_tmp_cp_ret4;
     447    struct ofstream *_tmp_cp_ret5;
    1135448    __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
    1136449        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
    1137450    }
    1138     ((void)(((void)(_tmp_cp_ret51=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1453))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1454))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1455, _Bool __anonymous_object1456))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1457))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1458, const char *__anonymous_object1459))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1460))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1463))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1464))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1467))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1468, const char *__anonymous_object1469))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1470))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1471, const char *__anonymous_object1472))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1473))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1474))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1475, const char *__anonymous_object1476, unsigned long int __anonymous_object1477))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1478, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret50=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(((_Bool (*)(void *__anonymous_object1479))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1480))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1481, _Bool __anonymous_object1482))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1483))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1484, const char *__anonymous_object1485))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1486))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1489))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1490))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1493))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1494, const char *__anonymous_object1495))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1496))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1497, const char *__anonymous_object1498))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1499))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1500))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1501, const char *__anonymous_object1502, unsigned long int __anonymous_object1503))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1504, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret49=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1505))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1506))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1507, _Bool __anonymous_object1508))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1509))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1510, const char *__anonymous_object1511))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1512))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1515))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1516))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1519))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1520, const char *__anonymous_object1521))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1522))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1523, const char *__anonymous_object1524))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1525))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1526))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1527, const char *__anonymous_object1528, unsigned long int __anonymous_object1529))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1530, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed char "))) , _tmp_cp_ret49), __v__Sc_1))) , _tmp_cp_ret50), ((void *(*)(void *__anonymous_object1531))(&_thunk1))))) , _tmp_cp_ret51));
    1139     ((void)(_tmp_cp_ret49) /* ^?{} */);
    1140     ((void)(_tmp_cp_ret50) /* ^?{} */);
    1141     ((void)(_tmp_cp_ret51) /* ^?{} */);
     451    ((void)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1453))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1454))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1455, _Bool __anonymous_object1456))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1457))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1458, const char *__anonymous_object1459))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1460))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1463))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1464))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1467))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1468, const char *__anonymous_object1469))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1470))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1471, const char *__anonymous_object1472))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1473))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1474))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1475, const char *__anonymous_object1476, unsigned long int __anonymous_object1477))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1478, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(((_Bool (*)(void *__anonymous_object1479))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1480))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1481, _Bool __anonymous_object1482))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1483))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1484, const char *__anonymous_object1485))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1486))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1489))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1490))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1493))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1494, const char *__anonymous_object1495))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1496))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1497, const char *__anonymous_object1498))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1499))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1500))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1501, const char *__anonymous_object1502, unsigned long int __anonymous_object1503))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1504, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1505))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1506))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1507, _Bool __anonymous_object1508))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1509))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1510, const char *__anonymous_object1511))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1512))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1515))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1516))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1519))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1520, const char *__anonymous_object1521))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1522))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1523, const char *__anonymous_object1524))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1525))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1526))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1527, const char *__anonymous_object1528, unsigned long int __anonymous_object1529))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1530, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed char "))) , _tmp_cp_ret3), __v__Sc_1))) , _tmp_cp_ret4), ((void *(*)(void *__anonymous_object1531))(&_thunk1))))) , _tmp_cp_ret5));
     452    ((void)(_tmp_cp_ret3) /* ^?{} */);
     453    ((void)(_tmp_cp_ret4) /* ^?{} */);
     454    ((void)(_tmp_cp_ret5) /* ^?{} */);
    1142455}
    1143456void __f__F_Uc__1(unsigned char __v__Uc_1){
    1144     struct ofstream *_tmp_cp_ret52;
    1145     struct ofstream *_tmp_cp_ret53;
    1146     struct ofstream *_tmp_cp_ret54;
     457    struct ofstream *_tmp_cp_ret6;
     458    struct ofstream *_tmp_cp_ret7;
     459    struct ofstream *_tmp_cp_ret8;
    1147460    __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
    1148461        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
    1149462    }
    1150     ((void)(((void)(_tmp_cp_ret54=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1558))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1559))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1560, _Bool __anonymous_object1561))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1562))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1563, const char *__anonymous_object1564))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1565))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1568))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1569))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1572))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1573, const char *__anonymous_object1574))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1575))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1576, const char *__anonymous_object1577))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1578))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1579))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1580, const char *__anonymous_object1581, unsigned long int __anonymous_object1582))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1583, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret53=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Uc__1(((_Bool (*)(void *__anonymous_object1584))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1585))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1586, _Bool __anonymous_object1587))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1588))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1589, const char *__anonymous_object1590))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1591))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1594))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1595))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1598))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1599, const char *__anonymous_object1600))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1601))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1602, const char *__anonymous_object1603))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1604))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1605))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1606, const char *__anonymous_object1607, unsigned long int __anonymous_object1608))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1609, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret52=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1610))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1611))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1612, _Bool __anonymous_object1613))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1614))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1615, const char *__anonymous_object1616))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1617))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1620))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1621))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1624))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1625, const char *__anonymous_object1626))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1627))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1628, const char *__anonymous_object1629))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1630))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1631))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1632, const char *__anonymous_object1633, unsigned long int __anonymous_object1634))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1635, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned char "))) , _tmp_cp_ret52), __v__Uc_1))) , _tmp_cp_ret53), ((void *(*)(void *__anonymous_object1636))(&_thunk2))))) , _tmp_cp_ret54));
    1151     ((void)(_tmp_cp_ret52) /* ^?{} */);
    1152     ((void)(_tmp_cp_ret53) /* ^?{} */);
    1153     ((void)(_tmp_cp_ret54) /* ^?{} */);
     463    ((void)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1558))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1559))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1560, _Bool __anonymous_object1561))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1562))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1563, const char *__anonymous_object1564))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1565))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1568))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1569))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1572))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1573, const char *__anonymous_object1574))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1575))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1576, const char *__anonymous_object1577))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1578))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1579))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1580, const char *__anonymous_object1581, unsigned long int __anonymous_object1582))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1583, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Uc__1(((_Bool (*)(void *__anonymous_object1584))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1585))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1586, _Bool __anonymous_object1587))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1588))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1589, const char *__anonymous_object1590))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1591))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1594))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1595))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1598))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1599, const char *__anonymous_object1600))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1601))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1602, const char *__anonymous_object1603))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1604))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1605))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1606, const char *__anonymous_object1607, unsigned long int __anonymous_object1608))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1609, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1610))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1611))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1612, _Bool __anonymous_object1613))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1614))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1615, const char *__anonymous_object1616))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1617))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1620))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1621))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1624))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1625, const char *__anonymous_object1626))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1627))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1628, const char *__anonymous_object1629))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1630))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1631))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1632, const char *__anonymous_object1633, unsigned long int __anonymous_object1634))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1635, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned char "))) , _tmp_cp_ret6), __v__Uc_1))) , _tmp_cp_ret7), ((void *(*)(void *__anonymous_object1636))(&_thunk2))))) , _tmp_cp_ret8));
     464    ((void)(_tmp_cp_ret6) /* ^?{} */);
     465    ((void)(_tmp_cp_ret7) /* ^?{} */);
     466    ((void)(_tmp_cp_ret8) /* ^?{} */);
    1154467}
    1155468void __f__F_s__1(signed short int __v__s_1){
    1156     struct ofstream *_tmp_cp_ret55;
    1157     struct ofstream *_tmp_cp_ret56;
    1158     struct ofstream *_tmp_cp_ret57;
     469    struct ofstream *_tmp_cp_ret9;
     470    struct ofstream *_tmp_cp_ret10;
     471    struct ofstream *_tmp_cp_ret11;
    1159472    __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
    1160473        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
    1161474    }
    1162     ((void)(((void)(_tmp_cp_ret57=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1663))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1664))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1665, _Bool __anonymous_object1666))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1667))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1668, const char *__anonymous_object1669))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1670))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1673))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1674))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1677))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1678, const char *__anonymous_object1679))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1680))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1681, const char *__anonymous_object1682))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1683))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1684))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1685, const char *__anonymous_object1686, unsigned long int __anonymous_object1687))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1688, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret56=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0s__1(((_Bool (*)(void *__anonymous_object1689))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1690))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1691, _Bool __anonymous_object1692))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1693))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1694, const char *__anonymous_object1695))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1696))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1699))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1700))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1703))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1704, const char *__anonymous_object1705))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1706))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1707, const char *__anonymous_object1708))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1709))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1710))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1711, const char *__anonymous_object1712, unsigned long int __anonymous_object1713))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1714, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret55=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1715))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1716))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1717, _Bool __anonymous_object1718))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1719))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1720, const char *__anonymous_object1721))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1722))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1725))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1726))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1729))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1730, const char *__anonymous_object1731))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1732))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1733, const char *__anonymous_object1734))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1735))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1736))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1737, const char *__anonymous_object1738, unsigned long int __anonymous_object1739))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1740, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed short int"))) , _tmp_cp_ret55), __v__s_1))) , _tmp_cp_ret56), ((void *(*)(void *__anonymous_object1741))(&_thunk3))))) , _tmp_cp_ret57));
    1163     ((void)(_tmp_cp_ret55) /* ^?{} */);
    1164     ((void)(_tmp_cp_ret56) /* ^?{} */);
    1165     ((void)(_tmp_cp_ret57) /* ^?{} */);
     475    ((void)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1663))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1664))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1665, _Bool __anonymous_object1666))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1667))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1668, const char *__anonymous_object1669))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1670))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1673))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1674))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1677))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1678, const char *__anonymous_object1679))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1680))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1681, const char *__anonymous_object1682))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1683))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1684))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1685, const char *__anonymous_object1686, unsigned long int __anonymous_object1687))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1688, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0s__1(((_Bool (*)(void *__anonymous_object1689))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1690))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1691, _Bool __anonymous_object1692))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1693))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1694, const char *__anonymous_object1695))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1696))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1699))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1700))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1703))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1704, const char *__anonymous_object1705))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1706))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1707, const char *__anonymous_object1708))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1709))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1710))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1711, const char *__anonymous_object1712, unsigned long int __anonymous_object1713))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1714, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1715))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1716))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1717, _Bool __anonymous_object1718))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1719))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1720, const char *__anonymous_object1721))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1722))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1725))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1726))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1729))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1730, const char *__anonymous_object1731))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1732))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1733, const char *__anonymous_object1734))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1735))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1736))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1737, const char *__anonymous_object1738, unsigned long int __anonymous_object1739))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1740, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed short int"))) , _tmp_cp_ret9), __v__s_1))) , _tmp_cp_ret10), ((void *(*)(void *__anonymous_object1741))(&_thunk3))))) , _tmp_cp_ret11));
     476    ((void)(_tmp_cp_ret9) /* ^?{} */);
     477    ((void)(_tmp_cp_ret10) /* ^?{} */);
     478    ((void)(_tmp_cp_ret11) /* ^?{} */);
    1166479}
    1167480void __f__F_Us__1(unsigned short int __v__Us_1){
    1168     struct ofstream *_tmp_cp_ret58;
    1169     struct ofstream *_tmp_cp_ret59;
    1170     struct ofstream *_tmp_cp_ret60;
     481    struct ofstream *_tmp_cp_ret12;
     482    struct ofstream *_tmp_cp_ret13;
     483    struct ofstream *_tmp_cp_ret14;
    1171484    __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
    1172485        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
    1173486    }
    1174     ((void)(((void)(_tmp_cp_ret60=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1768))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1769))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1770, _Bool __anonymous_object1771))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1772))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1773, const char *__anonymous_object1774))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1775))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1778))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1779))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1782))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1783, const char *__anonymous_object1784))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1785))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1786, const char *__anonymous_object1787))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1788))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1789))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1790, const char *__anonymous_object1791, unsigned long int __anonymous_object1792))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1793, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret59=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Us__1(((_Bool (*)(void *__anonymous_object1794))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1795))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1796, _Bool __anonymous_object1797))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1798))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1799, const char *__anonymous_object1800))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1801))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1804))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1805))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1808))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1809, const char *__anonymous_object1810))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1811))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1812, const char *__anonymous_object1813))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1814))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1815))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1816, const char *__anonymous_object1817, unsigned long int __anonymous_object1818))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1819, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret58=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1820))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1821))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1822, _Bool __anonymous_object1823))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1824))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1825, const char *__anonymous_object1826))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1827))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1830))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1831))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1834))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1835, const char *__anonymous_object1836))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1837))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1838, const char *__anonymous_object1839))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1840))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1841))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1842, const char *__anonymous_object1843, unsigned long int __anonymous_object1844))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1845, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned short int"))) , _tmp_cp_ret58), __v__Us_1))) , _tmp_cp_ret59), ((void *(*)(void *__anonymous_object1846))(&_thunk4))))) , _tmp_cp_ret60));
    1175     ((void)(_tmp_cp_ret58) /* ^?{} */);
    1176     ((void)(_tmp_cp_ret59) /* ^?{} */);
    1177     ((void)(_tmp_cp_ret60) /* ^?{} */);
     487    ((void)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1768))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1769))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1770, _Bool __anonymous_object1771))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1772))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1773, const char *__anonymous_object1774))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1775))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1778))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1779))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1782))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1783, const char *__anonymous_object1784))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1785))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1786, const char *__anonymous_object1787))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1788))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1789))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1790, const char *__anonymous_object1791, unsigned long int __anonymous_object1792))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1793, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Us__1(((_Bool (*)(void *__anonymous_object1794))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1795))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1796, _Bool __anonymous_object1797))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1798))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1799, const char *__anonymous_object1800))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1801))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1804))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1805))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1808))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1809, const char *__anonymous_object1810))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1811))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1812, const char *__anonymous_object1813))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1814))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1815))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1816, const char *__anonymous_object1817, unsigned long int __anonymous_object1818))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1819, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1820))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1821))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1822, _Bool __anonymous_object1823))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1824))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1825, const char *__anonymous_object1826))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1827))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1830))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1831))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1834))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1835, const char *__anonymous_object1836))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1837))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1838, const char *__anonymous_object1839))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1840))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1841))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1842, const char *__anonymous_object1843, unsigned long int __anonymous_object1844))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1845, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned short int"))) , _tmp_cp_ret12), __v__Us_1))) , _tmp_cp_ret13), ((void *(*)(void *__anonymous_object1846))(&_thunk4))))) , _tmp_cp_ret14));
     488    ((void)(_tmp_cp_ret12) /* ^?{} */);
     489    ((void)(_tmp_cp_ret13) /* ^?{} */);
     490    ((void)(_tmp_cp_ret14) /* ^?{} */);
    1178491}
    1179492void __f__F_Ul__1(unsigned long int __v__Ul_1){
    1180     struct ofstream *_tmp_cp_ret61;
    1181     struct ofstream *_tmp_cp_ret62;
    1182     struct ofstream *_tmp_cp_ret63;
     493    struct ofstream *_tmp_cp_ret15;
     494    struct ofstream *_tmp_cp_ret16;
     495    struct ofstream *_tmp_cp_ret17;
    1183496    __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
    1184497        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
    1185498    }
    1186     ((void)(((void)(_tmp_cp_ret63=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1873))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1874))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1875, _Bool __anonymous_object1876))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1877))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1878, const char *__anonymous_object1879))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1880))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1883))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1884))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1887))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1888, const char *__anonymous_object1889))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1890))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1891, const char *__anonymous_object1892))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1893))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1894))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1895, const char *__anonymous_object1896, unsigned long int __anonymous_object1897))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1898, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret62=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Ul__1(((_Bool (*)(void *__anonymous_object1899))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1900))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1901, _Bool __anonymous_object1902))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1903))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1904, const char *__anonymous_object1905))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1906))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1909))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1910))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1913))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1914, const char *__anonymous_object1915))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1916))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1917, const char *__anonymous_object1918))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1919))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1920))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1921, const char *__anonymous_object1922, unsigned long int __anonymous_object1923))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1924, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret61=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1925))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1926))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1927, _Bool __anonymous_object1928))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1929))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1930, const char *__anonymous_object1931))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1932))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1935))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1936))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1939))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1940, const char *__anonymous_object1941))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1942))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1943, const char *__anonymous_object1944))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1945))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1946))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1947, const char *__anonymous_object1948, unsigned long int __anonymous_object1949))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1950, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "size_t"))) , _tmp_cp_ret61), __v__Ul_1))) , _tmp_cp_ret62), ((void *(*)(void *__anonymous_object1951))(&_thunk5))))) , _tmp_cp_ret63));
    1187     ((void)(_tmp_cp_ret61) /* ^?{} */);
    1188     ((void)(_tmp_cp_ret62) /* ^?{} */);
    1189     ((void)(_tmp_cp_ret63) /* ^?{} */);
     499    ((void)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1873))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1874))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1875, _Bool __anonymous_object1876))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1877))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1878, const char *__anonymous_object1879))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1880))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1883))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1884))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1887))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1888, const char *__anonymous_object1889))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1890))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1891, const char *__anonymous_object1892))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1893))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1894))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1895, const char *__anonymous_object1896, unsigned long int __anonymous_object1897))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1898, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Ul__1(((_Bool (*)(void *__anonymous_object1899))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1900))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1901, _Bool __anonymous_object1902))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1903))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1904, const char *__anonymous_object1905))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1906))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1909))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1910))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1913))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1914, const char *__anonymous_object1915))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1916))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1917, const char *__anonymous_object1918))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1919))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1920))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1921, const char *__anonymous_object1922, unsigned long int __anonymous_object1923))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1924, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1925))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1926))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1927, _Bool __anonymous_object1928))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1929))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1930, const char *__anonymous_object1931))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1932))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1935))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1936))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1939))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1940, const char *__anonymous_object1941))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1942))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1943, const char *__anonymous_object1944))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1945))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1946))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1947, const char *__anonymous_object1948, unsigned long int __anonymous_object1949))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1950, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "size_t"))) , _tmp_cp_ret15), __v__Ul_1))) , _tmp_cp_ret16), ((void *(*)(void *__anonymous_object1951))(&_thunk5))))) , _tmp_cp_ret17));
     500    ((void)(_tmp_cp_ret15) /* ^?{} */);
     501    ((void)(_tmp_cp_ret16) /* ^?{} */);
     502    ((void)(_tmp_cp_ret17) /* ^?{} */);
    1190503}
    1191504signed int __main__Fi___1(){
Note: See TracChangeset for help on using the changeset viewer.