Changeset 32cab5b for src


Ignore:
Timestamp:
Apr 17, 2018, 12:01:09 PM (7 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc
Children:
3265399
Parents:
b2fe1c9 (diff), 81bb114 (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:
11 added
2 deleted
81 edited
1 moved

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    rb2fe1c9 r32cab5b  
    203203
    204204        void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
    205                 genAttributes( aggDecl->get_attributes() );
    206 
    207205                if( ! aggDecl->get_parameters().empty() && ! genC ) {
    208206                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
    … …  
    213211                }
    214212
    215                 output << kind << aggDecl->get_name();
     213                output << kind;
     214                genAttributes( aggDecl->get_attributes() );
     215                output << aggDecl->get_name();
    216216
    217217                if ( aggDecl->has_body() ) {
    … …  
    298298                        output << " }";
    299299                }
     300        }
     301
     302        void CodeGenerator::postvisit( StaticAssertDecl * assertDecl ) {
     303                output << "_Static_assert(";
     304                assertDecl->condition->accept( *visitor );
     305                output << ", ";
     306                assertDecl->message->accept( *visitor );
     307                output << ")";
    300308        }
    301309
    … …  
    928936                        output << "continue";
    929937                        break;
     938                  case BranchStmt::FallThrough:
     939                  case BranchStmt::FallThroughDefault:
     940                        assertf( ! genC, "fallthru should not reach code generation." );
     941                  output << "fallthru";
     942                        break;
    930943                } // switch
     944                // print branch target for labelled break/continue/fallthru in debug mode
     945                if ( ! genC && branchStmt->get_type() != BranchStmt::Goto ) {
     946                        if ( ! branchStmt->get_target().empty() ) {
     947                                output << " " << branchStmt->get_target();
     948                        } else if ( branchStmt->get_type() == BranchStmt::FallThrough ) {
     949                                output << " default";
     950                        }
     951                }
    931952                output << ";";
    932953        }

  • src/CodeGen/CodeGenerator.h

    rb2fe1c9 r32cab5b  
    4242                void postvisit( FunctionDecl * );
    4343                void postvisit( ObjectDecl * );
    44                 void postvisit( UnionDecl *aggregateDecl );
    45                 void postvisit( EnumDecl *aggregateDecl );
    46                 void postvisit( TraitDecl *aggregateDecl );
    47                 void postvisit( TypedefDecl *typeDecl );
    48                 void postvisit( TypeDecl *typeDecl );
     44                void postvisit( UnionDecl * aggregateDecl );
     45                void postvisit( EnumDecl * aggregateDecl );
     46                void postvisit( TraitDecl * aggregateDecl );
     47                void postvisit( TypedefDecl * typeDecl );
     48                void postvisit( TypeDecl * typeDecl );
     49                void postvisit( StaticAssertDecl * assertDecl );
    4950
    5051                //*** Initializer

  • src/CodeGen/OperatorTable.cc

    rb2fe1c9 r32cab5b  
    7979        } // namespace
    8080
    81         bool operatorLookup( std::string funcName, OperatorInfo &info ) {
     81        bool operatorLookup( const std::string & funcName, OperatorInfo & info ) {
    8282                static bool init = false;
    8383                if ( ! init ) {
    … …  
    100100                        return true;
    101101                } // if
     102        }
     103
     104        bool isOperator( const std::string & funcName ) {
     105                OperatorInfo info;
     106                return operatorLookup( funcName, info );
    102107        }
    103108

  • src/CodeGen/OperatorTable.h

    rb2fe1c9 r32cab5b  
    4141        };
    4242
    43         bool operatorLookup( std::string funcName, OperatorInfo &info );
     43        bool isOperator( const std::string & funcName );
     44        bool operatorLookup( const std::string & funcName, OperatorInfo & info );
    4445
    4546        bool isConstructor( const std::string & );

  • src/Common/Debug.h

    rb2fe1c9 r32cab5b  
    2828namespace Debug {
    2929        /// debug codegen a translation unit
    30         static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) {
     30        static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
    3131        #ifdef DEBUG
    3232                std::list< Declaration * > decls;
    3333
    34                 filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) {
    35                         return ! LinkageSpec::isBuiltin( decl->get_linkage() );
     34                filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), [linkageFilter]( Declaration * decl ) {
     35                        return ! (decl->linkage & linkageFilter);
    3636                });
    3737
    3838                std::cerr << "======" << label << "======" << std::endl;
    39                 CodeGen::generate( decls, std::cerr, false, true );
     39                CodeGen::generate( decls, std::cerr, true, true );
    4040        #endif
    4141        } // dump
    4242
    43         static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) {
     43        static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
    4444        #ifdef DEBUG
    4545                std::list< Declaration * > decls;
    4646
    47                 filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) {
    48                         return ! LinkageSpec::isBuiltin( decl->get_linkage() );
     47                filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), [linkageFilter]( Declaration * decl ) {
     48                        return ! (decl->linkage & linkageFilter);
    4949                });
    5050

  • src/Common/ErrorObjects.h

    rb2fe1c9 r32cab5b  
    3535class SemanticErrorException : public std::exception {
    3636  public:
    37         SemanticErrorException() = default;
     37        SemanticErrorException() = default;
    3838        SemanticErrorException( CodeLocation location, std::string error );
    3939        ~SemanticErrorException() throw() {}

  • src/Common/PassVisitor.h

    rb2fe1c9 r32cab5b  
    6666        virtual void visit( TypedefDecl * typeDecl ) override final;
    6767        virtual void visit( AsmDecl * asmDecl ) override final;
     68        virtual void visit( StaticAssertDecl * assertDecl ) override final;
    6869
    6970        virtual void visit( CompoundStmt * compoundStmt ) override final;
    … …  
    161162        virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
    162163        virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
     164        virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
    163165
    164166        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;

  • src/Common/PassVisitor.impl.h

    rb2fe1c9 r32cab5b  
    685685
    686686//--------------------------------------------------------------------------
     687// StaticAssertDecl
     688template< typename pass_type >
     689void PassVisitor< pass_type >::visit( StaticAssertDecl * node ) {
     690        VISIT_START( node );
     691
     692        maybeAccept_impl( node->condition, *this );
     693        maybeAccept_impl( node->message  , *this );
     694
     695        VISIT_END( node );
     696}
     697
     698template< typename pass_type >
     699StaticAssertDecl * PassVisitor< pass_type >::mutate( StaticAssertDecl * node ) {
     700        MUTATE_START( node );
     701
     702        maybeMutate_impl( node->condition, *this );
     703        maybeMutate_impl( node->message  , *this );
     704
     705        MUTATE_END( StaticAssertDecl, node );
     706}
     707
     708//--------------------------------------------------------------------------
    687709// CompoundStmt
    688710template< typename pass_type >
    … …  
    14901512        indexerScopedAccept( node->result, *this );
    14911513        maybeAccept_impl   ( node->type  , *this );
    1492         maybeAccept_impl   ( node->member, *this );
    14931514
    14941515        VISIT_END( node );
    … …  
    15021523        indexerScopedMutate( node->result, *this );
    15031524        maybeMutate_impl   ( node->type  , *this );
    1504         maybeMutate_impl   ( node->member, *this );
    15051525
    15061526        MUTATE_END( Expression, node );

  • src/Common/SemanticError.h

    rb2fe1c9 r32cab5b  
    3838constexpr const char * const WarningFormats[] = {
    3939        "self assignment of expression: %s",
     40        "rvalue to reference conversion of rvalue: %s",
    4041};
    4142
    4243enum class Warning {
    4344        SelfAssignment,
     45        RvalueToReferenceConversion,
    4446        NUMBER_OF_WARNINGS, //This MUST be the last warning
    4547};
    … …  
    5052);
    5153
    52 #define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id], __VA_ARGS__)
     54// ## used here to allow empty __VA_ARGS__
     55#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id], ## __VA_ARGS__)
    5356
    5457void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4)));

  • src/ControlStruct/ExceptTranslate.cc

    rb2fe1c9 r32cab5b  
    3434#include "SynTree/Statement.h"        // for CompoundStmt, CatchStmt, ThrowStmt
    3535#include "SynTree/Type.h"             // for FunctionType, Type, noQualifiers
    36 #include "SynTree/VarExprReplacer.h"  // for VarExprReplacer, VarExprReplace...
     36#include "SynTree/DeclReplacer.h"     // for DeclReplacer
    3737#include "SynTree/Visitor.h"          // for acceptAll
    3838
    … …  
    314314                        // Update variables in the body to point to this local copy.
    315315                        {
    316                                 VarExprReplacer::DeclMap mapping;
     316                                DeclReplacer::DeclMap mapping;
    317317                                mapping[ handler_decl ] = local_except;
    318                                 VarExprReplacer::replace( handler->body, mapping );
     318                                DeclReplacer::replace( handler->body, mapping );
    319319                        }
    320320

  • src/ControlStruct/MLEMutator.cc

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 11:21:32 2016
    13 // Update Count     : 202
     12// Last Modified On : Thu Mar  8 17:08:25 2018
     13// Update Count     : 219
    1414//
    1515
    … …  
    3838        }
    3939        namespace {
    40                 Statement * isLoop( Statement * stmt ) { return dynamic_cast< WhileStmt * >( stmt ) ? stmt : dynamic_cast< ForStmt * >( stmt ) ? stmt : 0; }
    41         }
     40                bool isLoop( const MLEMutator::Entry & e ) { return dynamic_cast< WhileStmt * >( e.get_controlStructure() ) || dynamic_cast< ForStmt * >( e.get_controlStructure() ); }
     41                bool isSwitch( const MLEMutator::Entry & e ) { return dynamic_cast< SwitchStmt *>( e.get_controlStructure() ); }
     42
     43                bool isBreakTarget( const MLEMutator::Entry & e ) { return isLoop( e ) || isSwitch( e ) || dynamic_cast< CompoundStmt *>( e.get_controlStructure() ); }
     44                bool isContinueTarget( const MLEMutator::Entry & e ) { return isLoop( e ); }
     45                bool isFallthroughTarget( const MLEMutator::Entry & e ) { return dynamic_cast< CaseStmt *>( e.get_controlStructure() );; }
     46                bool isFallthroughDefaultTarget( const MLEMutator::Entry & e ) { return isSwitch( e ); }
     47        } // namespace
    4248
    4349        // break labels have to come after the statement they break out of, so mutate a statement, then if they inform us
    4450        // through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the
    4551        // body of statements
    46         void MLEMutator::fixBlock( std::list< Statement * > &kids ) {
     52        void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) {
     53                SemanticErrorException errors;
     54
    4755                for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) {
    48                         *k = (*k)->acceptMutator(*visitor);
     56                        if ( caseClause ) {
     57                                // once a label is seen, it's no longer a valid fallthrough target
     58                                for ( Label & l : (*k)->labels ) {
     59                                        fallthroughLabels.erase( l );
     60                                }
     61                        }
     62
     63                        // aggregate errors since the PassVisitor mutate loop was unrollled
     64                        try {
     65                                *k = (*k)->acceptMutator(*visitor);
     66                        } catch( SemanticErrorException &e ) {
     67                                errors.append( e );
     68                        }
    4969
    5070                        if ( ! get_breakLabel().empty() ) {
    … …  
    5575                        } // if
    5676                } // for
     77
     78                if ( ! errors.isEmpty() ) {
     79                        throw errors;
     80                }
    5781        }
    5882
    … …  
    6387                        Label brkLabel = generator->newLabel("blockBreak", cmpndStmt);
    6488                        enclosingControlStructures.push_back( Entry( cmpndStmt, brkLabel ) );
     89                        GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
    6590                } // if
    6691
    … …  
    7499                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
    75100                        } // if
    76                         enclosingControlStructures.pop_back();
    77101                } // if
    78102        }
    … …  
    112136                                        if ( isContinue ) {
    113137                                                // continue target is outermost loop
    114                                                 targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), [](Entry &e) { return isLoop( e.get_controlStructure() ); } );
     138                                                targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isContinueTarget );
    115139                                        } else {
    116                                                 // break target is outmost control structure
    117                                                 if ( enclosingControlStructures.empty() ) SemanticError( branchStmt->location, "'break' outside a loop, switch, or labelled block" );
    118                                                 targetEntry = enclosingControlStructures.rbegin();
     140                                                // break target is outermost loop, switch, or block control structure
     141                                                if ( enclosingControlStructures.empty() ) SemanticError( branchStmt->location, "'break' outside a loop, 'switch', or labelled block" );
     142                                                targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isBreakTarget );
    119143                                        } // if
    120144                                } else {
    … …  
    123147                                } // if
    124148                                // ensure that selected target is valid
    125                                 if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isLoop( targetEntry->get_controlStructure() ) ) ) {
     149                                if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isContinueTarget( *targetEntry ) ) ) {
    126150                                        SemanticError( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
    127151                                } // if
    128152                                break;
    129153                        }
     154                        case BranchStmt::FallThrough:
     155                                targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isFallthroughTarget );
     156                                // ensure that selected target is valid
     157                                if ( targetEntry == enclosingControlStructures.rend() ) {
     158                                        SemanticError( branchStmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     159                                } // if
     160                                if ( branchStmt->get_target() != "" ) {
     161                                        // labelled fallthrough
     162                                        // target must be in the set of valid fallthrough labels
     163                                        if ( ! fallthroughLabels.count( branchStmt->get_target() ) ) {
     164                                                SemanticError( branchStmt->location, toString( "'fallthrough' target must be a later case statement: ", originalTarget ) );
     165                                        }
     166                                        return new BranchStmt( originalTarget, BranchStmt::Goto );
     167                                }
     168                                break;
     169                        case BranchStmt::FallThroughDefault: {
     170                                // fallthrough default
     171                                targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isFallthroughDefaultTarget );
     172
     173                                // ensure that fallthrough is within a switch or choose
     174                                if ( targetEntry == enclosingControlStructures.rend() ) {
     175                                        SemanticError( branchStmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     176                                } // if
     177
     178                                // ensure that switch or choose has a default clause
     179                                SwitchStmt * switchStmt = strict_dynamic_cast< SwitchStmt * >( targetEntry->get_controlStructure() );
     180                                bool foundDefault = false;
     181                                for ( Statement * stmt : switchStmt->statements ) {
     182                                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     183                                        if ( caseStmt->isDefault() ) {
     184                                                foundDefault = true;
     185                                        } // if
     186                                } // for
     187                                if ( ! foundDefault ) {
     188                                        SemanticError( branchStmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
     189                                }
     190                                break;
     191                        }
     192
    130193                        default:
    131194                                assert( false );
    … …  
    142205                                assert( targetEntry->useContExit() != "");
    143206                                exitLabel = targetEntry->useContExit();
     207                                break;
     208                  case BranchStmt::FallThrough:
     209                                assert( targetEntry->useFallExit() != "");
     210                                exitLabel = targetEntry->useFallExit();
     211                                break;
     212                  case BranchStmt::FallThroughDefault:
     213                                assert( targetEntry->useFallDefaultExit() != "");
     214                                exitLabel = targetEntry->useFallDefaultExit();
     215                                // check that fallthrough default comes before the default clause
     216                                if ( ! targetEntry->isFallDefaultValid() ) {
     217                                        SemanticError( branchStmt->location, "'fallthrough default' must precede the 'default' clause" );
     218                                }
    144219                                break;
    145220                  default:
    … …  
    187262                Label contLabel = generator->newLabel("loopContinue", loopStmt);
    188263                enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
     264                GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
    189265        }
    190266
    … …  
    197273
    198274                // this will take the necessary steps to add definitions of the previous two labels, if they are used.
    199                 loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
    200                 enclosingControlStructures.pop_back();
     275                loopStmt->body = mutateLoop( loopStmt->get_body(), e );
    201276                return loopStmt;
    202277        }
    … …  
    224299                        Label brkLabel = generator->newLabel("blockBreak", ifStmt);
    225300                        enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
     301                        GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
    226302                } // if
    227303        }
    … …  
    233309                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
    234310                        } // if
    235                         enclosingControlStructures.pop_back();
    236311                } // if
    237312                return ifStmt;
    … …  
    240315        void MLEMutator::premutate( CaseStmt *caseStmt ) {
    241316                visit_children = false;
     317
     318                // mark default as seen before visiting its statements to catch default loops
     319                if ( caseStmt->isDefault() ) {
     320                        enclosingControlStructures.back().seenDefault();
     321                } // if
     322
    242323                caseStmt->condition = maybeMutate( caseStmt->condition, *visitor );
    243                 fixBlock( caseStmt->stmts );
     324                Label fallLabel = generator->newLabel( "fallThrough", caseStmt );
     325                {
     326                        // ensure that stack isn't corrupted by exceptions in fixBlock
     327                        auto guard = makeFuncGuard( [&]() { enclosingControlStructures.push_back( Entry( caseStmt, fallLabel ) ); }, [this]() { enclosingControlStructures.pop_back(); } );
     328
     329                        // empty case statement
     330                        if( ! caseStmt->stmts.empty() ) {
     331                                // the parser ensures that all statements in a case are grouped into a block
     332                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
     333                                fixBlock( block->kids, true );
     334
     335                                // add fallthrough label if necessary
     336                                assert( ! enclosingControlStructures.empty() );
     337                                if ( enclosingControlStructures.back().isFallUsed() ) {
     338                                        std::list<Label> ls{ enclosingControlStructures.back().useFallExit() };
     339                                        caseStmt->stmts.push_back( new NullStmt( ls ) );
     340                                } // if
     341                        } // if
     342                }
     343                assert( ! enclosingControlStructures.empty() );
     344                assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ), "Control structure enclosing a case clause must be a switch, but is: %s", toCString( enclosingControlStructures.back().get_controlStructure() ) );
     345                if ( caseStmt->isDefault() ) {
     346                        if ( enclosingControlStructures.back().isFallDefaultUsed() ) {
     347                                // add fallthrough default label if necessary
     348                                std::list<Label> ls{ enclosingControlStructures.back().useFallDefaultExit() };
     349                                caseStmt->stmts.push_front( new NullStmt( ls ) );
     350                        } // if
     351                } // if
    244352        }
    245353
    … …  
    247355                // generate a label for breaking out of a labeled switch
    248356                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
    249                 enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
     357                auto it = std::find_if( switchStmt->statements.rbegin(), switchStmt->statements.rend(), [](Statement * stmt) {
     358                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     359                        return caseStmt->isDefault();
     360                });
     361                CaseStmt * defaultCase = it != switchStmt->statements.rend() ? strict_dynamic_cast<CaseStmt *>( *it ) : nullptr;
     362                Label fallDefaultLabel = defaultCase ? generator->newLabel( "fallThroughDefault", defaultCase ) : "";
     363                enclosingControlStructures.push_back( Entry(switchStmt, brkLabel, fallDefaultLabel) );
     364                GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
     365
     366                // Collect valid labels for fallthrough. This is initially all labels at the same level as a case statement.
     367                // As labels are seen during traversal, they are removed, since fallthrough is not allowed to jump backwards.
     368                for ( Statement * stmt : switchStmt->statements ) {
     369                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     370                        if ( caseStmt->stmts.empty() ) continue;
     371                        CompoundStmt * block = dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
     372                        for ( Statement * stmt : block->kids ) {
     373                                for ( Label & l : stmt->labels ) {
     374                                        fallthroughLabels.insert( l );
     375                                }
     376                        }
     377                }
    250378        }
    251379
    … …  
    272400
    273401                assert ( enclosingControlStructures.back() == switchStmt );
    274                 enclosingControlStructures.pop_back();
    275402                return switchStmt;
    276403        }

  • src/ControlStruct/MLEMutator.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:19:59 2017
    13 // Update Count     : 35
     12// Last Modified On : Thu Mar  8 16:42:32 2018
     13// Update Count     : 41
    1414//
    1515
    … …  
    1919#include <map>                     // for map
    2020#include <string>                  // for string
     21#include <set>                     // for unordered_set
    2122
    2223#include "Common/PassVisitor.h"
    … …  
    2930        class LabelGenerator;
    3031
    31         class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting {
     32        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting, public WithGuards {
     33          public:
    3234                class Entry;
    33 
    34           public:
    3535                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
    3636                ~MLEMutator();
    … …  
    5252                Label &get_breakLabel() { return breakLabel; }
    5353                void set_breakLabel( Label newValue ) { breakLabel = newValue; }
    54           private:
     54
    5555                class Entry {
    5656                  public:
    57                         explicit Entry( Statement *_loop, Label _breakExit, Label _contExit = Label("") ) :
    58                                 loop( _loop ), breakExit( _breakExit ), contExit( _contExit ), breakUsed(false), contUsed(false) {}
     57                        // specialized constructors for each combination of statement with labelled break/continue/fallthrough that is valid to cleanup the use cases
     58                        explicit Entry( ForStmt *stmt, Label breakExit, Label contExit ) :
     59                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
    5960
    60                         bool operator==( const Statement *stmt ) { return loop == stmt; }
    61                         bool operator!=( const Statement *stmt ) { return loop != stmt; }
     61                        explicit Entry( WhileStmt *stmt, Label breakExit, Label contExit ) :
     62                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
    6263
    63                         bool operator==( const Entry &other ) { return loop == other.get_controlStructure(); }
     64                        explicit Entry( CompoundStmt *stmt, Label breakExit ) :
     65                                stmt( stmt ), breakExit( breakExit ) {}
    6466
    65                         Statement *get_controlStructure() const { return loop; }
     67                        explicit Entry( IfStmt *stmt, Label breakExit ) :
     68                                stmt( stmt ), breakExit( breakExit ) {}
     69
     70                        explicit Entry( CaseStmt *stmt, Label fallExit ) :
     71                                stmt( stmt ), fallExit( fallExit ) {}
     72
     73                        explicit Entry( SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
     74                                stmt( stmt ), breakExit( breakExit ), fallDefaultExit( fallDefaultExit ) {}
     75
     76                        bool operator==( const Statement *other ) { return stmt == other; }
     77                        bool operator!=( const Statement *other ) { return stmt != other; }
     78
     79                        bool operator==( const Entry &other ) { return stmt == other.get_controlStructure(); }
     80
     81                        Statement *get_controlStructure() const { return stmt; }
    6682
    6783                        Label useContExit() { contUsed = true; return contExit; }
    6884                        Label useBreakExit() { breakUsed = true; return breakExit; }
     85                        Label useFallExit() { fallUsed = true; return fallExit; }
     86                        Label useFallDefaultExit() { fallDefaultUsed = true; return fallDefaultExit; }
    6987
    7088                        bool isContUsed() const { return contUsed; }
    7189                        bool isBreakUsed() const { return breakUsed; }
     90                        bool isFallUsed() const { return fallUsed; }
     91                        bool isFallDefaultUsed() const { return fallDefaultUsed; }
     92                        void seenDefault() { fallDefaultValid = false; }
     93                        bool isFallDefaultValid() const { return fallDefaultValid; }
    7294                  private:
    73                         Statement *loop;
    74                         Label breakExit, contExit;
    75                         bool breakUsed, contUsed;
     95                        Statement *stmt;
     96                        Label breakExit, contExit, fallExit, fallDefaultExit;
     97                        bool breakUsed = false, contUsed = false, fallUsed = false, fallDefaultUsed = false;
     98                        bool fallDefaultValid = true;
    7699                };
    77100
     101          private:
    78102                std::map< Label, Statement * > *targetTable;
     103                std::set< Label > fallthroughLabels;
    79104                std::list< Entry > enclosingControlStructures;
    80105                Label breakLabel;
    … …  
    87112                Statement * posthandleLoopStmt( LoopClass * loopStmt );
    88113
    89                 void fixBlock( std::list< Statement * > &kids );
     114                void fixBlock( std::list< Statement * > &kids, bool caseClause = false );
    90115        };
    91116} // namespace ControlStruct

  • src/GenPoly/GenPoly.cc

    rb2fe1c9 r32cab5b  
    100100                if ( dynamic_cast< TypeInstType * >( type ) ) {
    101101                        return type;
     102                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
     103                        return isPolyType( arrayType->base, env );
    102104                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
    103105                        if ( hasPolyParams( structType->get_parameters(), env ) ) return type;
    … …  
    115117                                return type;
    116118                        }
     119                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
     120                        return isPolyType( arrayType->base, tyVars, env );
    117121                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
    118122                        if ( hasPolyParams( structType->get_parameters(), tyVars, env ) ) return type;

  • src/GenPoly/Lvalue.cc

    rb2fe1c9 r32cab5b  
    4545                Expression * mkDeref( Expression * arg ) {
    4646                        if ( SymTab::dereferenceOperator ) {
     47                                // note: reference depth can be arbitrarily deep here, so peel off the outermost pointer/reference, not just pointer because they are effecitvely equivalent in this pass
    4748                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
    4849                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
    … …  
    5960                }
    6061
    61                 struct ReferenceConversions final {
     62                struct ReferenceConversions final : public WithStmtsToAdd {
    6263                        Expression * postmutate( CastExpr * castExpr );
    6364                        Expression * postmutate( AddressExpr * addrExpr );
    … …  
    114115        }
    115116
    116         void convertLvalue( std::list< Declaration* >& translationUnit ) {
     117        void convertLvalue( std::list< Declaration* > & translationUnit ) {
    117118                PassVisitor<ReferenceConversions> refCvt;
    118119                PassVisitor<ReferenceTypeElimination> elim;
    … …  
    150151                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
    151152                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
    152                                         Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
    153                                         return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
     153                                        Type * ret = ftype->returnVals.empty() ? nullptr : ftype->returnVals.front()->get_type();
     154                                        return func->linkage == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
    154155                                }
    155156                        }
    … …  
    160161                        if ( isIntrinsicReference( appExpr ) ) {
    161162                                // eliminate reference types from intrinsic applications - now they return lvalues
    162                                 Type * result = appExpr->get_result();
    163                                 appExpr->set_result( result->stripReferences()->clone() );
    164                                 appExpr->get_result()->set_lvalue( true );
     163                                Type * result = appExpr->result;
     164                                appExpr->result = result->stripReferences()->clone();
     165                                appExpr->result->set_lvalue( true );
    165166                                if ( ! inIntrinsic ) {
    166167                                        // when not in an intrinsic function, add a cast to
    167168                                        // don't add cast when in an intrinsic function, since they already have the cast
    168169                                        Expression * ret = new CastExpr( appExpr, result );
    169                                         ret->set_env( appExpr->get_env() );
    170                                         appExpr->set_env( nullptr );
     170                                        std::swap( ret->env, appExpr->env );
    171171                                        return ret;
    172172                                }
    … …  
    187187                                assertf( ftype, "Function declaration does not have function type." );
    188188                                // can be of differing lengths only when function is variadic
    189                                 assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
     189                                assertf( ftype->parameters.size() == appExpr->args.size() || ftype->isVarArgs, "ApplicationExpr args do not match formal parameter type." );
    190190
    191191
    192192                                unsigned int i = 0;
    193                                 const unsigned int end = ftype->get_parameters().size();
    194                                 for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
     193                                const unsigned int end = ftype->parameters.size();
     194                                for ( auto p : unsafe_group_iterate( appExpr->args, ftype->parameters ) ) {
    195195                                        if (i == end) break;
    196196                                        Expression *& arg = std::get<0>( p );
    … …  
    198198                                        PRINT(
    199199                                                std::cerr << "pair<0>: " << arg << std::endl;
     200                                                std::cerr << " -- " << arg->result << std::endl;
    200201                                                std::cerr << "pair<1>: " << formal << std::endl;
    201202                                        )
    202203                                        if ( dynamic_cast<ReferenceType*>( formal ) ) {
    203                                                 if ( isIntrinsicReference( arg ) ) { // do not combine conditions, because that changes the meaning of the else if
    204                                                         if ( function->get_linkage() != LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references
    205                                                                 // if argument is dereference or array subscript, the result isn't REALLY a reference, so it's not necessary to fix the argument
    206                                                                 PRINT(
    207                                                                         std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
    208                                                                 )
    209                                                                 arg = new AddressExpr( arg );
    210                                                         }
    211                                                 } else if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
    212                                                         // std::cerr << "===adding deref to arg" << std::endl;
    213                                                         // if the parameter is a reference, add a dereference to the reference-typed argument.
    214                                                         Type * baseType = InitTweak::getPointerBase( arg->get_result() );
    215                                                         assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
     204                                                PRINT(
     205                                                        std::cerr << "===formal is reference" << std::endl;
     206                                                )
     207                                                // TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
     208                                                if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
     209                                                        // if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
     210                                                        PRINT(
     211                                                                std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
     212                                                        )
     213                                                        arg = new AddressExpr( arg );
     214                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
     215                                                        // argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
     216                                                        PRINT(
     217                                                                std::cerr << "===is non-intrinsic arg in intrinsic call - adding deref to arg" << std::endl;
     218                                                        )
     219                                                        Type * baseType = InitTweak::getPointerBase( arg->result );
     220                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->result ).c_str() );
    216221                                                        PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
    217                                                         delete arg->get_result();
     222                                                        delete arg->result;
    218223                                                        arg->set_result( ptrType );
    219224                                                        arg = mkDeref( arg );
     225                                                        assertf( arg->result->referenceDepth() == 0, "Reference types should have been eliminated from intrinsic function calls, but weren't: %s", toCString( arg->result ) );
    220226                                                }
    221227                                        }
    … …  
    249255                Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
    250256                        if ( refDepth == 0 ) {
    251                                 if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) {
     257                                if ( ! isIntrinsicReference( addrExpr->arg ) ) {
    252258                                        // try to avoid ?[?]
    253                                         refDepth = addrExpr->get_arg()->get_result()->referenceDepth();
     259                                        refDepth = addrExpr->arg->result->referenceDepth();
    254260                                }
    255261                        }
    … …  
    280286                        // pointer casts in the right places.
    281287
    282                         // conversion to reference type
    283                         if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
    284                                 (void)refType;
    285                                 if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
    286                                         // nothing to do if casting from reference to reference.
    287                                         (void)otherRef;
    288                                         PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; )
    289                                         if ( isIntrinsicReference( castExpr->get_arg() ) ) {
    290                                                 Expression * callExpr = castExpr->get_arg();
    291                                                 PRINT(
    292                                                         std::cerr << "but arg is deref -- &" << std::endl;
    293                                                         std::cerr << callExpr << std::endl;
    294                                                 )
    295                                                 callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
    296                                                 delete callExpr->get_result();
    297                                                 callExpr->set_result( refType->clone() );
    298                                                 // move environment out to new top-level
    299                                                 callExpr->set_env( castExpr->get_env() );
    300                                                 castExpr->set_arg( nullptr );
    301                                                 castExpr->set_env( nullptr );
    302                                                 delete castExpr;
    303                                                 return callExpr;
    304                                         }
    305                                         int depth1 = refType->referenceDepth();
    306                                         int depth2 = otherRef->referenceDepth();
    307                                         int diff = depth1-depth2;
    308                                         if ( diff == 0 ) {
    309                                                 // conversion between references of the same depth
    310                                                 assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
    311                                                 PRINT( std::cerr << castExpr << std::endl; )
    312                                                 return castExpr;
    313                                         } else if ( diff < 0 ) {
    314                                                 // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
    315                                                 Expression * ret = castExpr->arg;
    316                                                 for ( int i = 0; i < diff; ++i ) {
    317                                                         ret = mkDeref( ret );
    318                                                 }
    319                                                 ret->env = castExpr->env;
    320                                                 delete ret->result;
    321                                                 ret->result = castExpr->result;
    322                                                 ret->result->set_lvalue( true ); // ensure result is lvalue
    323                                                 castExpr->env = nullptr;
    324                                                 castExpr->arg = nullptr;
    325                                                 castExpr->result = nullptr;
    326                                                 delete castExpr;
    327                                                 return ret;
    328                                         } else if ( diff > 0 ) {
    329                                                 // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
    330                                                 Expression * ret = castExpr->arg;
    331                                                 for ( int i = 0; i < diff; ++i ) {
    332                                                         ret = new AddressExpr( ret );
    333                                                 }
    334                                                 ret->env = castExpr->env;
    335                                                 delete ret->result;
    336                                                 ret->result = castExpr->result;
    337                                                 castExpr->env = nullptr;
    338                                                 castExpr->arg = nullptr;
    339                                                 castExpr->result = nullptr;
    340                                                 delete castExpr;
    341                                                 return ret;
    342                                         }
    343 
    344                                         assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
    345                                         PRINT( std::cerr << castExpr << std::endl; )
     288                        // Note: reference depth difference is the determining factor in what code is run, rather than whether something is
     289                        // reference type or not, since conversion still needs to occur when both types are references that differ in depth.
     290
     291                        Type * destType = castExpr->result;
     292                        Type * srcType = castExpr->arg->result;
     293                        int depth1 = destType->referenceDepth();
     294                        int depth2 = srcType->referenceDepth();
     295                        int diff = depth1 - depth2;
     296
     297                        if ( diff > 0 && ! srcType->get_lvalue() ) {
     298                                // rvalue to reference conversion -- introduce temporary
     299                                // know that reference depth of cast argument is 0, need to introduce n temporaries for reference depth of n, e.g.
     300                                //   (int &&&)3;
     301                                // becomes
     302                                //   int __ref_tmp_0 = 3;
     303                                //   int & __ref_tmp_1 = _&_ref_tmp_0;
     304                                //   int && __ref_tmp_2 = &__ref_tmp_1;
     305                                //   &__ref_tmp_2;
     306                                // the last & comes from the remaining reference conversion code
     307                                SemanticWarning( castExpr->arg->location, Warning::RvalueToReferenceConversion, toCString( castExpr->arg ) );
     308
     309                                static UniqueName tempNamer( "__ref_tmp_" );
     310                                ObjectDecl * temp = ObjectDecl::newObject( tempNamer.newName(), castExpr->arg->result->clone(), new SingleInit( castExpr->arg ) );
     311                                PRINT( std::cerr << "made temp: " << temp << std::endl; )
     312                                stmtsToAddBefore.push_back( new DeclStmt( temp ) );
     313                                for ( int i = 0; i < depth1-1; i++ ) { // xxx - maybe this should be diff-1? check how this works with reference type for srcType
     314                                        ObjectDecl * newTemp = ObjectDecl::newObject( tempNamer.newName(), new ReferenceType( Type::Qualifiers(), temp->type->clone() ), new SingleInit( new AddressExpr( new VariableExpr( temp ) ) ) );
     315                                        PRINT( std::cerr << "made temp" << i << ": " << newTemp << std::endl; )
     316                                        stmtsToAddBefore.push_back( new DeclStmt( newTemp ) );
     317                                        temp = newTemp;
     318                                }
     319                                // update diff so that remaining code works out correctly
     320                                castExpr->arg = new VariableExpr( temp );
     321                                PRINT( std::cerr << "update cast to: " << castExpr << std::endl; )
     322                                srcType = castExpr->arg->result;
     323                                depth2 = srcType->referenceDepth();
     324                                diff = depth1 - depth2;
     325                                assert( diff == 1 );
     326                        }
     327
     328                        // handle conversion between different depths
     329                        PRINT (
     330                                if ( depth1 || depth2 ) {
     331                                        std::cerr << "destType: " << destType << " / srcType: " << srcType << std::endl;
     332                                        std::cerr << "depth: " << depth1 << " / " << depth2 << std::endl;
     333                                }
     334                        )
     335                        if ( diff > 0 ) {
     336                                // conversion to type with more depth (e.g. int & -> int &&): add address-of for each level of difference
     337                                Expression * ret = castExpr->arg;
     338                                for ( int i = 0; i < diff; ++i ) {
     339                                        ret = new AddressExpr( ret );
     340                                }
     341                                if ( srcType->get_lvalue() && srcType->get_qualifiers() != strict_dynamic_cast<ReferenceType *>( destType )->base->get_qualifiers() ) {
     342                                        // must keep cast if cast-to type is different from the actual type
     343                                        castExpr->arg = ret;
    346344                                        return castExpr;
    347                                 } else if ( castExpr->arg->result->get_lvalue() ) {
    348                                         // conversion from lvalue to reference
    349                                         // xxx - keep cast, but turn into pointer cast??
    350                                         // xxx - memory
    351                                         PRINT(
    352                                                 std::cerr << "convert lvalue to reference -- &" << std::endl;
    353                                                 std::cerr << castExpr->arg << std::endl;
    354                                         )
    355                                         AddressExpr * ret = new AddressExpr( castExpr->arg );
    356                                         if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
    357                                                 // must keep cast if cast-to type is different from the actual type
    358                                                 castExpr->arg = ret;
    359                                                 return castExpr;
    360                                         }
    361                                         ret->env = castExpr->env;
    362                                         delete ret->result;
    363                                         ret->result = castExpr->result;
    364                                         castExpr->env = nullptr;
    365                                         castExpr->arg = nullptr;
    366                                         castExpr->result = nullptr;
    367                                         delete castExpr;
    368                                         return ret;
    369                                 } else {
    370                                         // rvalue to reference conversion -- introduce temporary
    371                                 }
    372                                 assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
    373                         } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
    374                                 (void)refType;
    375                                 // conversion from reference to rvalue
    376                                 PRINT(
    377                                         std::cerr << "convert reference to rvalue -- *" << std::endl;
    378                                         std::cerr << "was = " << castExpr << std::endl;
    379                                 )
     345                                }
     346                                ret->env = castExpr->env;
     347                                delete ret->result;
     348                                ret->result = castExpr->result;
     349                                castExpr->env = nullptr;
     350                                castExpr->arg = nullptr;
     351                                castExpr->result = nullptr;
     352                                delete castExpr;
     353                                return ret;
     354                        } else if ( diff < 0 ) {
     355                                // conversion to type with less depth (e.g. int && -> int &): add dereferences for each level of difference
     356                                diff = -diff; // care only about magnitude now
    380357                                Expression * ret = castExpr->arg;
    381                                 TypeSubstitution * env = castExpr->env;
    382                                 castExpr->set_env( nullptr );
    383                                 if ( ! isIntrinsicReference( ret ) ) {
    384                                         // dereference if not already dereferenced
     358                                for ( int i = 0; i < diff; ++i ) {
    385359                                        ret = mkDeref( ret );
    386360                                }
    387                                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
    388                                         // can remove cast if types are compatible, changing expression type to value type
    389                                         ret->result = castExpr->result->clone();
    390                                         ret->result->set_lvalue( true );  // ensure result is lvalue
    391                                         castExpr->arg = nullptr;
    392                                         delete castExpr;
    393                                 } else {
     361                                if ( ! ResolvExpr::typesCompatibleIgnoreQualifiers( destType->stripReferences(), srcType->stripReferences(), SymTab::Indexer() ) ) {
    394362                                        // must keep cast if types are different
    395363                                        castExpr->arg = ret;
    396                                         ret = castExpr;
    397                                 }
    398                                 ret->set_env( env );
    399                                 PRINT( std::cerr << "now: " << ret << std::endl; )
    400                                 return ret;
    401                         }
    402                         return castExpr;
     364                                        return castExpr;
     365                                }
     366                                ret->env = castExpr->env;
     367                                delete ret->result;
     368                                ret->result = castExpr->result;
     369                                ret->result->set_lvalue( true ); // ensure result is lvalue
     370                                castExpr->env = nullptr;
     371                                castExpr->arg = nullptr;
     372                                castExpr->result = nullptr;
     373                                delete castExpr;
     374                                return ret;
     375                        } else {
     376                                assert( diff == 0 );
     377                                // conversion between references of the same depth
     378                                return castExpr;
     379                        }
    403380                }
    404381
    405382                Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
    406                         Type * base = refType->get_base();
     383                        Type * base = refType->base;
    407384                        Type::Qualifiers qualifiers = refType->get_qualifiers();
    408                         refType->set_base( nullptr );
     385                        refType->base = nullptr;
    409386                        delete refType;
    410387                        return new PointerType( qualifiers, base );
    … …  
    414391                Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
    415392                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
    416                                 Expression * arg1 = commaExpr->get_arg1()->clone();
    417                                 Expression * arg2 = commaExpr->get_arg2()->clone();
     393                                Expression * arg1 = commaExpr->arg1->clone();
     394                                Expression * arg2 = commaExpr->arg2->clone();
    418395                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
    419                                 ret->set_env( expr->get_env() );
    420                                 expr->set_env( nullptr );
     396                                ret->env = expr->env;
     397                                expr->env = nullptr;
    421398                                delete expr;
    422399                                return ret;
    423400                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
    424                                 Expression * arg1 = condExpr->get_arg1()->clone();
    425                                 Expression * arg2 = condExpr->get_arg2()->clone();
    426                                 Expression * arg3 = condExpr->get_arg3()->clone();
     401                                Expression * arg1 = condExpr->arg1->clone();
     402                                Expression * arg2 = condExpr->arg2->clone();
     403                                Expression * arg3 = condExpr->arg3->clone();
    427404                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
    428                                 ret->set_env( expr->get_env() );
    429                                 expr->set_env( nullptr );
     405                                ret->env = expr->env;
     406                                expr->env = nullptr;
    430407                                delete expr;
    431408
    … …  
    436413                                AssertionSet needAssertions, haveAssertions;
    437414                                OpenVarSet openVars;
    438                                 unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
    439                                 ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
     415                                unify( ret->arg2->result, ret->arg3->result, newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
     416                                ret->result = commonType ? commonType : ret->arg2->result->clone();
    440417                                return ret;
    441418                        }
    … …  
    444421
    445422                Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
    446                         return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
     423                        return applyTransformation( memExpr, memExpr->aggregate, [=]( Expression * aggr ) { return new MemberExpr( memExpr->member, aggr ); } );
    447424                }
    448425
    449426                Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
    450                         return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
     427                        return applyTransformation( addrExpr, addrExpr->arg, []( Expression * arg ) { return new AddressExpr( arg ); } );
    451428                }
    452429
    453430                Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) {
    454                         Expression * arg = addrExpr->get_arg();
     431                        Expression * arg = addrExpr->arg;
    455432                        if ( isIntrinsicReference( arg ) ) {
    456433                                std::string fname = InitTweak::getFunctionName( arg );
    … …  
    458435                                        Expression *& arg0 = InitTweak::getCallArg( arg, 0 );
    459436                                        Expression * ret = arg0;
    460                                         ret->set_env( addrExpr->get_env() );
     437                                        ret->set_env( addrExpr->env );
    461438                                        arg0 = nullptr;
    462                                         addrExpr->set_env( nullptr );
     439                                        addrExpr->env = nullptr;
    463440                                        delete addrExpr;
    464441                                        return ret;
    … …  
    487464                                        // }
    488465                                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) {
    489                                                 Expression * ret = addrExpr->get_arg();
    490                                                 ret->set_env( appExpr->get_env() );
    491                                                 addrExpr->set_arg( nullptr );
    492                                                 appExpr->set_env( nullptr );
     466                                                Expression * ret = addrExpr->arg;
     467                                                ret->env = appExpr->env;
     468                                                addrExpr->arg = nullptr;
     469                                                appExpr->env = nullptr;
    493470                                                delete appExpr;
    494471                                                return ret;

  • src/Makefile.in

    rb2fe1c9 r32cab5b  
    249249        SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
    250250        SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
    251         SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
     251        SynTree/driver_cfa_cpp-DeclReplacer.$(OBJEXT) \
    252252        Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
    253253        Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT) \
    … …  
    526526        SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
    527527        SynTree/Initializer.cc SynTree/TypeSubstitution.cc \
    528         SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
     528        SynTree/Attribute.cc SynTree/DeclReplacer.cc \
    529529        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
    530530        Tuples/Explode.cc Virtual/ExpandCasts.cc
    … …  
    912912SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
    913913        SynTree/$(DEPDIR)/$(am__dirstamp)
    914 SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
     914SynTree/driver_cfa_cpp-DeclReplacer.$(OBJEXT):  \
    915915        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
    916916Tuples/$(am__dirstamp):
    … …  
    10391039@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-CompoundStmt.Po@am__quote@
    10401040@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Constant.Po@am__quote@
     1041@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Po@am__quote@
    10411042@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-DeclStmt.Po@am__quote@
    10421043@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Declaration.Po@am__quote@
    … …  
    10601061@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeofType.Po@am__quote@
    10611062@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po@am__quote@
    1062 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po@am__quote@
    10631063@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
    10641064@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
    … …  
    24982498@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
    24992499
    2500 SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
    2501 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
    2502 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
    2503 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.o' libtool=no @AMDEPBACKSLASH@
    2504 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2505 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
    2506 
    2507 SynTree/driver_cfa_cpp-VarExprReplacer.obj: SynTree/VarExprReplacer.cc
    2508 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
    2509 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
    2510 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.obj' libtool=no @AMDEPBACKSLASH@
    2511 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2512 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
     2500SynTree/driver_cfa_cpp-DeclReplacer.o: SynTree/DeclReplacer.cc
     2501@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-DeclReplacer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Tpo -c -o SynTree/driver_cfa_cpp-DeclReplacer.o `test -f 'SynTree/DeclReplacer.cc' || echo '$(srcdir)/'`SynTree/DeclReplacer.cc
     2502@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Po
     2503@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/DeclReplacer.cc' object='SynTree/driver_cfa_cpp-DeclReplacer.o' libtool=no @AMDEPBACKSLASH@
     2504@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2505@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-DeclReplacer.o `test -f 'SynTree/DeclReplacer.cc' || echo '$(srcdir)/'`SynTree/DeclReplacer.cc
     2506
     2507SynTree/driver_cfa_cpp-DeclReplacer.obj: SynTree/DeclReplacer.cc
     2508@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-DeclReplacer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Tpo -c -o SynTree/driver_cfa_cpp-DeclReplacer.obj `if test -f 'SynTree/DeclReplacer.cc'; then $(CYGPATH_W) 'SynTree/DeclReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/DeclReplacer.cc'; fi`
     2509@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Po
     2510@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/DeclReplacer.cc' object='SynTree/driver_cfa_cpp-DeclReplacer.obj' libtool=no @AMDEPBACKSLASH@
     2511@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2512@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-DeclReplacer.obj `if test -f 'SynTree/DeclReplacer.cc'; then $(CYGPATH_W) 'SynTree/DeclReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/DeclReplacer.cc'; fi`
    25132513
    25142514Tuples/driver_cfa_cpp-TupleAssignment.o: Tuples/TupleAssignment.cc

  • src/Parser/DeclarationNode.cc

    rb2fe1c9 r32cab5b  
    7171        attr.expr = nullptr;
    7272        attr.type = nullptr;
     73
     74        assert.condition = nullptr;
     75        assert.message = nullptr;
    7376}
    7477
    … …  
    8891        // asmName, no delete, passed to next stage
    8992        delete initializer;
     93
     94        delete assert.condition;
     95        delete assert.message;
    9096}
    9197
    … …  
    117123        newnode->attr.expr = maybeClone( attr.expr );
    118124        newnode->attr.type = maybeClone( attr.type );
     125
     126        newnode->assert.condition = maybeClone( assert.condition );
     127        newnode->assert.message = maybeClone( assert.message );
    119128        return newnode;
    120129} // DeclarationNode::clone
    … …  
    434443        return newnode;
    435444}
     445
     446DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, Expression * message ) {
     447        DeclarationNode * newnode = new DeclarationNode;
     448        newnode->assert.condition = condition;
     449        newnode->assert.message = message;
     450        return newnode;
     451}
     452
    436453
    437454void appendError( string & dst, const string & src ) {
    … …  
    10521069        } // if
    10531070
     1071        if ( assert.condition ) {
     1072                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
     1073        }
     1074
    10541075        // SUE's cannot have function specifiers, either
    10551076        //

  • src/Parser/ExpressionNode.cc

    rb2fe1c9 r32cab5b  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Mar  3 18:22:33 2018
    13 // Update Count     : 796
     12// Last Modified On : Thu Mar 22 11:57:39 2018
     13// Update Count     : 801
    1414//
    1515
    … …  
    9494} // checkLNInt
    9595
    96 static void sepNumeric( string & str, string & units ) {
    97         string::size_type posn = str.find_first_of( "`" );
    98         if ( posn != string::npos ) {
    99                 units = "?" + str.substr( posn );                               // extract units
    100                 str.erase( posn );                                                              // remove units
    101         } // if
    102 } // sepNumeric
    103 
    10496Expression * build_constantInteger( string & str ) {
    10597        static const BasicType::Kind kind[2][6] = {
    … …  
    108100                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
    109101        };
    110 
    111         string units;
    112         sepNumeric( str, units );                                                       // separate constant from units
    113102
    114103        bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
    … …  
    232221        } // if
    233222  CLEANUP:
    234         if ( units.length() != 0 ) {
    235                 ret = new UntypedExpr( new NameExpr( units ), { ret } );
    236         } // if
    237223
    238224        delete &str;                                                                            // created by lex
    … …  
    268254        };
    269255
    270         string units;
    271         sepNumeric( str, units );                                                       // separate constant from units
    272 
    273256        bool complx = false;                                                            // real, complex
    274257        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
    … …  
    303286        if ( lnth != -1 ) {                                                                     // explicit length ?
    304287                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) );
    305         } // if
    306         if ( units.length() != 0 ) {
    307                 ret = new UntypedExpr( new NameExpr( units ), { ret } );
    308288        } // if
    309289

  • src/Parser/ParseNode.h

    rb2fe1c9 r32cab5b  
    246246        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
    247247        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
     248        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
    248249
    249250        DeclarationNode();
    … …  
    313314        Attr_t attr;
    314315
     316        struct StaticAssert_t {
     317                ExpressionNode * condition;
     318                Expression * message;
     319        };
     320        StaticAssert_t assert;
     321
    315322        BuiltinType builtin;
    316323
    … …  
    392399
    393400Statement * build_if( IfCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
    394 Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
     401Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
    395402Statement * build_case( ExpressionNode * ctl );
    396403Statement * build_default();

  • src/Parser/StatementNode.cc

    rb2fe1c9 r32cab5b  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Sep  1 23:25:23 2017
    13 // Update Count     : 346
     12// Last Modified On : Thu Mar  8 14:31:32 2018
     13// Update Count     : 348
    1414//
    1515
    … …  
    116116}
    117117
    118 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
     118Statement *build_switch( bool isSwitch, ExpressionNode *ctl, StatementNode *stmt ) {
    119119        std::list< Statement * > branches;
    120120        buildMoveList< Statement, StatementNode >( stmt, branches );
     121        if ( ! isSwitch ) {                                                                             // choose statement
     122                for ( Statement * stmt : branches ) {
     123                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     124                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
     125                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
     126                                block->kids.push_back( new BranchStmt( "", BranchStmt::Break ) );
     127                        } // if
     128                } // for
     129        } // if
    121130        // branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
    122131        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );

  • src/Parser/lex.ll

    rb2fe1c9 r32cab5b  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Sat Mar  3 18:38:16 2018
    13  * Update Count     : 640
     12 * Last Modified On : Fri Apr  6 15:16:15 2018
     13 * Update Count     : 670
    1414 */
    1515
    … …  
    5454
    5555void rm_underscore() {
    56         // Remove underscores in numeric constant by copying the non-underscore characters to the front of the string.
     56        // SKULLDUGGERY: remove underscores (ok to shorten?)
    5757        yyleng = 0;
    58         for ( int i = 0; yytext[i] != '\0'; i += 1 ) {
    59                 if ( yytext[i] == '`' ) {
    60                         // copy user suffix
    61                         for ( ; yytext[i] != '\0'; i += 1 ) {
    62                                 yytext[yyleng] = yytext[i];
    63                                 yyleng += 1;
    64                         } // for
    65                         break;
    66                 } // if
     58        for ( int i = 0; yytext[i] != '\0'; i += 1 ) {          // copying non-underscore characters to front of string
    6759                if ( yytext[i] != '_' ) {
    6860                        yytext[yyleng] = yytext[i];
    … …  
    7163        } // for
    7264        yytext[yyleng] = '\0';
    73 }
     65} // rm_underscore
    7466
    7567// Stop warning due to incorrectly generated flex code.
    … …  
    9082attr_identifier "@"{identifier}
    9183
    92 user_suffix_opt ("`"{identifier})?
    93 
    9484                                // numeric constants, CFA: '_' in constant
    9585hex_quad {hex}("_"?{hex}){3}
    9686size_opt (8|16|32|64|128)?
    9787length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
    98 integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
     88integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?
    9989
    10090octal_digits ({octal})|({octal}({octal}|"_")*{octal})
    … …  
    118108floating_length ([fFdDlL]|[lL]{floating_size})
    119109floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
    120 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
     110floating_suffix_opt ("_"?({floating_suffix}|"DL"))?
    121111decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
    122112floating_decimal {decimal_digits}"."{exponent}?{floating_suffix_opt}
    … …  
    125115
    126116binary_exponent "_"?[pP]"_"?[+-]?{decimal_digits}
    127 hex_floating_suffix_opt ("_"?({floating_suffix}))?{user_suffix_opt}
     117hex_floating_suffix_opt ("_"?({floating_suffix}))?
    128118hex_floating_fraction ({hex_digits}?"."{hex_digits})|({hex_digits}".")
    129119hex_floating_constant {hex_prefix}(({hex_floating_fraction}{binary_exponent})|({hex_digits}{binary_exponent})){hex_floating_suffix_opt}
    … …  
    208198__asm                   { KEYWORD_RETURN(ASM); }                                // GCC
    209199__asm__                 { KEYWORD_RETURN(ASM); }                                // GCC
    210 _At                             { KEYWORD_RETURN(AT); }                                 // CFA
    211200_Atomic                 { KEYWORD_RETURN(ATOMIC); }                             // C11
    212201__attribute             { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
    … …  
    239228exception               { KEYWORD_RETURN(EXCEPTION); }                  // CFA
    240229extern                  { KEYWORD_RETURN(EXTERN); }
     230fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
    241231fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA
    242 fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
    243232finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
    244233float                   { KEYWORD_RETURN(FLOAT); }
    … …  
    270259__builtin_offsetof { KEYWORD_RETURN(OFFSETOF); }                // GCC
    271260one_t                   { NUMERIC_RETURN(ONE_T); }                              // CFA
     261or                              { QKEYWORD_RETURN(WOR); }                               // CFA
    272262otype                   { KEYWORD_RETURN(OTYPE); }                              // CFA
    273263register                { KEYWORD_RETURN(REGISTER); }
    … …  
    306296__volatile__    { KEYWORD_RETURN(VOLATILE); }                   // GCC
    307297waitfor                 { KEYWORD_RETURN(WAITFOR); }
    308 or                              { QKEYWORD_RETURN(WOR); }                               // CFA
    309298when                    { KEYWORD_RETURN(WHEN); }
    310299while                   { KEYWORD_RETURN(WHILE); }
    … …  
    314303                                /* identifier */
    315304{identifier}    { IDENTIFIER_RETURN(); }
     305"`"{identifier}"`" {                                                                    // CFA
     306        yytext[yyleng - 1] = '\0'; yytext += 1;                         // SKULLDUGGERY: remove backquotes (ok to shorten?)
     307        IDENTIFIER_RETURN();
     308}
    316309{attr_identifier} { ATTRIBUTE_RETURN(); }
    317 "`"                             { BEGIN BKQUOTE; }
    318 <BKQUOTE>{identifier} { IDENTIFIER_RETURN(); }
    319 <BKQUOTE>"`"    { BEGIN 0; }
    320310
    321311                                /* numeric constants */
    … …  
    332322({cwide_prefix}[_]?)?['] { BEGIN QUOTE; rm_underscore(); strtext = new string( yytext, yyleng ); }
    333323<QUOTE>[^'\\\n]* { strtext->append( yytext, yyleng ); }
    334 <QUOTE>['\n]{user_suffix_opt}   { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
     324<QUOTE>['\n]    { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    335325                                /* ' stop editor highlighting */
    336326
    … …  
    338328({swide_prefix}[_]?)?["] { BEGIN STRING; rm_underscore(); strtext = new string( yytext, yyleng ); }
    339329<STRING>[^"\\\n]* { strtext->append( yytext, yyleng ); }
    340 <STRING>["\n]{user_suffix_opt}  { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
     330<STRING>["\n]   { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    341331                                /* " stop editor highlighting */
    342332
    … …  
    348338                                /* punctuation */
    349339"@"                             { ASCIIOP_RETURN(); }
     340"`"                             { ASCIIOP_RETURN(); }
    350341"["                             { ASCIIOP_RETURN(); }
    351342"]"                             { ASCIIOP_RETURN(); }
    … …  
    412403"?"({op_unary_pre_post}|"()"|"[?]"|"{}") { IDENTIFIER_RETURN(); }
    413404"^?{}"                  { IDENTIFIER_RETURN(); }
    414 "?`"{identifier} { IDENTIFIER_RETURN(); }                               // unit operator
     405"?`"{identifier} { IDENTIFIER_RETURN(); }                               // postfix operator
    415406"?"{op_binary_over}"?"  { IDENTIFIER_RETURN(); }                // binary
    416407        /*

  • src/Parser/parser.yy

    rb2fe1c9 r32cab5b  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 17:48:54 2018
    13 // Update Count     : 3028
     12// Last Modified On : Wed Mar 28 17:52:24 2018
     13// Update Count     : 3130
    1414//
    1515
    … …  
    126126        } // if
    127127} // rebindForall
     128
     129NameExpr * build_postfix_name( const string * name ) {
     130        NameExpr * new_name = build_varref( new string( "?`" + *name ) );
     131        delete name;
     132        return new_name;
     133} // build_postfix_name
    128134
    129135bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
    … …  
    254260%type<sn> statement_decl                                statement_decl_list                     statement_list_nodecl
    255261%type<sn> selection_statement
    256 %type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
     262%type<sn> switch_clause_list_opt                switch_clause_list
    257263%type<en> case_value
    258264%type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
    259 %type<sn> fall_through                                  fall_through_opt
    260265%type<sn> iteration_statement                   jump_statement
    261266%type<sn> expression_statement                  asm_statement
    … …  
    481486        | '(' compound_statement ')'                                            // GCC, lambda expression
    482487                { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
     488        | constant '`' IDENTIFIER                                                       // CFA, postfix call
     489                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
     490        | string_literal '`' IDENTIFIER                                         // CFA, postfix call
     491                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( $1 ) ) ); }
     492        | IDENTIFIER '`' IDENTIFIER                                                     // CFA, postfix call
     493                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), new ExpressionNode( build_varref( $1 ) ) ) ); }
     494        | tuple '`' IDENTIFIER                                                          // CFA, postfix call
     495                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $3 ) ), $1 ) ); }
     496        | '(' comma_expression ')' '`' IDENTIFIER                       // CFA, postfix call
     497                { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
    483498        | type_name '.' no_attr_identifier                                      // CFA, nested type
    484                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
     499                { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
    485500        | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
    486                 { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
     501                { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
    487502        | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
    488                 { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; } // FIX ME
     503                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
    489504        ;
    490505
    … …  
    535550        | '(' type_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
    536551                { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
     552        | '(' type_no_function ')' '@' '{' initializer_list comma_opt '}' // CFA, explicit C compound-literal
     553                { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
    537554        | '^' primary_expression '{' argument_expression_list '}' // CFA
    538555                {
    … …  
    670687        | '(' type_no_function ')' cast_expression
    671688                { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
     689        | '(' COROUTINE '&' ')' cast_expression                         // CFA
     690                { SemanticError( yylloc, "coroutine cast is currently unimplemented." ); $$ = nullptr; }
     691        | '(' THREAD '&' ')' cast_expression                            // CFA
     692                { SemanticError( yylloc, "monitor cast is currently unimplemented." ); $$ = nullptr; }
     693        | '(' MONITOR '&' ')' cast_expression                           // CFA
     694                { SemanticError( yylloc, "thread cast is currently unimplemented." ); $$ = nullptr; }
    672695                // VIRTUAL cannot be opt because of look ahead issues
    673         | '(' VIRTUAL ')' cast_expression
     696        | '(' VIRTUAL ')' cast_expression                                       // CFA
    674697                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $4 ), maybeMoveBuildType( nullptr ) ) ); }
    675         | '(' VIRTUAL type_no_function ')' cast_expression
     698        | '(' VIRTUAL type_no_function ')' cast_expression      // CFA
    676699                { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $5 ), maybeMoveBuildType( $3 ) ) ); }
    677700//      | '(' type_no_function ')' tuple
    … …  
    765788        | logical_OR_expression '?' comma_expression ':' conditional_expression
    766789                { $$ = new ExpressionNode( build_cond( $1, $3, $5 ) ); }
    767                 // FIX ME: this hack computes $1 twice
     790                // FIX ME: computes $1 twice
    768791        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    769792                { $$ = new ExpressionNode( build_cond( $1, $1, $4 ) ); }
    … …  
    780803                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
    781804        | unary_expression '=' '{' initializer_list comma_opt '}'
    782                 { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME
     805                { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
    783806        ;
    784807
    … …  
    850873        | exception_statement
    851874        | enable_disable_statement
    852                 { SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
     875                { SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; }
    853876        | asm_statement
    854877        ;
    … …  
    917940                { $$ = new StatementNode( build_if( $4, $6, $8 ) ); }
    918941        | SWITCH '(' comma_expression ')' case_clause
    919                 { $$ = new StatementNode( build_switch( $3, $5 ) ); }
     942                { $$ = new StatementNode( build_switch( true, $3, $5 ) ); }
    920943        | SWITCH '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
    921944                {
    922                         StatementNode *sw = new StatementNode( build_switch( $3, $8 ) );
     945                        StatementNode *sw = new StatementNode( build_switch( true, $3, $8 ) );
    923946                        // The semantics of the declaration list is changed to include associated initialization, which is performed
    924947                        // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
    … …  
    929952                }
    930953        | CHOOSE '(' comma_expression ')' case_clause           // CFA
    931                 { $$ = new StatementNode( build_switch( $3, $5 ) ); }
    932         | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt choose_clause_list_opt '}' // CFA
    933                 {
    934                         StatementNode *sw = new StatementNode( build_switch( $3, $8 ) );
     954                { $$ = new StatementNode( build_switch( false, $3, $5 ) ); }
     955        | CHOOSE '(' comma_expression ')' '{' push declaration_list_opt switch_clause_list_opt '}' // CFA
     956                {
     957                        StatementNode *sw = new StatementNode( build_switch( false, $3, $8 ) );
    935958                        $$ = $7 ? new StatementNode( build_compound( (StatementNode *)((new StatementNode( $7 ))->set_last( sw )) ) ) : sw;
    936959                }
    … …  
    970993        ;
    971994
     995//label_list_opt:
     996//      // empty
     997//      | identifier_or_type_name ':'
     998//      | label_list_opt identifier_or_type_name ':'
     999//      ;
     1000
    9721001case_label_list:                                                                                // CFA
    9731002        case_label
    … …  
    9901019        | switch_clause_list case_label_list statement_list_nodecl
    9911020                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( $3 ) ) ) ) ); }
    992         ;
    993 
    994 choose_clause_list_opt:                                                                 // CFA
    995         // empty
    996                 { $$ = nullptr; }
    997         | choose_clause_list
    998         ;
    999 
    1000 choose_clause_list:                                                                             // CFA
    1001         case_label_list fall_through
    1002                 { $$ = $1->append_last_case( $2 ); }
    1003         | case_label_list statement_list_nodecl fall_through_opt
    1004                 { $$ = $1->append_last_case( new StatementNode( build_compound( (StatementNode *)$2->set_last( $3 ) ) ) ); }
    1005         | choose_clause_list case_label_list fall_through
    1006                 { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( $3 ))); }
    1007         | choose_clause_list case_label_list statement_list_nodecl fall_through_opt
    1008                 { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new StatementNode( build_compound( (StatementNode *)$3->set_last( $4 ) ) ) ) ) ); }
    1009         ;
    1010 
    1011 fall_through_opt:                                                                               // CFA
    1012         // empty
    1013                 { $$ = new StatementNode( build_branch( BranchStmt::Break ) ); } // insert implicit break
    1014         | fall_through
    1015         ;
    1016 
    1017 fall_through_name:                                                                              // CFA
    1018         FALLTHRU
    1019         | FALLTHROUGH
    1020         ;
    1021 
    1022 fall_through:                                                                                   // CFA
    1023         fall_through_name
    1024                 { $$ = nullptr; }
    1025         | fall_through_name ';'
    1026                 { $$ = nullptr; }
    10271021        ;
    10281022
    … …  
    10501044                // whereas normal operator precedence yields goto (*i)+3;
    10511045                { $$ = new StatementNode( build_computedgoto( $3 ) ); }
     1046                // A semantic check is required to ensure fallthru appears only in the body of a choose statement.
     1047    | fall_through_name ';'                                                             // CFA
     1048                { $$ = new StatementNode( build_branch( BranchStmt::FallThrough ) ); }
     1049    | fall_through_name identifier_or_type_name ';'             // CFA
     1050                { $$ = new StatementNode( build_branch( $2, BranchStmt::FallThrough ) ); }
     1051        | fall_through_name DEFAULT ';'                                         // CFA
     1052                { $$ = new StatementNode( build_branch( BranchStmt::FallThroughDefault ) ); }
    10521053        | CONTINUE ';'
    10531054                // A semantic check is required to ensure this statement appears only in the body of an iteration statement.
    … …  
    10671068                { $$ = new StatementNode( build_return( $2 ) ); }
    10681069        | RETURN '{' initializer_list comma_opt '}'
    1069                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME
     1070                { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
    10701071        | THROW assignment_expression_opt ';'                           // handles rethrow
    10711072                { $$ = new StatementNode( build_throw( $2 ) ); }
    … …  
    10761077        ;
    10771078
     1079fall_through_name:                                                                              // CFA
     1080        FALLTHRU
     1081        | FALLTHROUGH
     1082        ;
     1083
    10781084with_statement:
    10791085        WITH '(' tuple_expression_list ')' statement
    … …  
    10861092mutex_statement:
    10871093        MUTEX '(' argument_expression_list ')' statement
    1088                 { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
     1094                { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
    10891095        ;
    10901096
    10911097when_clause:
    1092         WHEN '(' comma_expression ')'
    1093                 { $$ = $3; }
     1098        WHEN '(' comma_expression ')'                           { $$ = $3; }
    10941099        ;
    10951100
    … …  
    11151120
    11161121timeout:
    1117         TIMEOUT '(' comma_expression ')'
    1118                 { $$ = $3; }
     1122        TIMEOUT '(' comma_expression ')'                        { $$ = $3; }
    11191123        ;
    11201124
    … …  
    11591163        //empty
    11601164                { $$ = nullptr; }
    1161         | ';' conditional_expression
    1162                 { $$ = $2; }
     1165        | ';' conditional_expression                            { $$ = $2; }
    11631166        ;
    11641167
    11651168handler_key:
    1166         CATCH
    1167                 { $$ = CatchStmt::Terminate; }
    1168         | CATCHRESUME
    1169                 { $$ = CatchStmt::Resume; }
     1169        CATCH                                                                           { $$ = CatchStmt::Terminate; }
     1170        | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
    11701171        ;
    11711172
    11721173finally_clause:
    1173         FINALLY compound_statement
    1174                 {
    1175                         $$ = new StatementNode( build_finally( $2 ) );
    1176                 }
     1174        FINALLY compound_statement                                      { $$ = new StatementNode( build_finally( $2 ) ); }
    11771175        ;
    11781176
    … …  
    13161314static_assert:
    13171315        STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
    1318                 { SemanticError( yylloc, "Static assert is currently unimplemented." ); $$ = nullptr; } // FIX ME
     1316                { $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
    13191317
    13201318// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
    … …  
    24132411                        $$ = $2;
    24142412                }
    2415         | forall '{' external_definition_list '}'                       // CFA, namespace
     2413        | type_qualifier_list '{' external_definition_list '}'                  // CFA, namespace
    24162414        ;
    24172415

  • src/ResolvExpr/CommonType.cc

    rb2fe1c9 r32cab5b  
    2828
    2929// #define DEBUG
     30#ifdef DEBUG
     31#define PRINT(x) x
     32#else
     33#define PRINT(x)
     34#endif
    3035
    3136namespace ResolvExpr {
    … …  
    7075                // need unify to bind type variables
    7176                if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) {
    72                         // std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
     77                        PRINT(
     78                                std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
     79                        )
    7380                        if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) {
    74                                 // std::cerr << "widen okay" << std::endl;
     81                                PRINT(
     82                                        std::cerr << "widen okay" << std::endl;
     83                                )
    7584                                common->get_qualifiers() |= t1->get_qualifiers();
    7685                                common->get_qualifiers() |= t2->get_qualifiers();
    … …  
    7887                        }
    7988                }
    80                 // std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
     89                PRINT(
     90                        std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
     91                )
    8192                return nullptr;
    8293        }
    … …  
    94105                        // special case where one type has a reference depth of 1 larger than the other
    95106                        if ( diff > 0 || diff < 0 ) {
    96                                 // std::cerr << "reference depth diff: " << diff << std::endl;
     107                                PRINT(
     108                                        std::cerr << "reference depth diff: " << diff << std::endl;
     109                                )
    97110                                Type * result = nullptr;
    98111                                ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
    … …  
    109122                                if ( result && ref1 ) {
    110123                                        // formal is reference, so result should be reference
    111                                         // std::cerr << "formal is reference; result should be reference" << std::endl;
     124                                        PRINT(
     125                                                std::cerr << "formal is reference; result should be reference" << std::endl;
     126                                        )
    112127                                        result = new ReferenceType( ref1->get_qualifiers(), result );
    113128                                }
    114                                 // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
     129                                PRINT(
     130                                        std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
     131                                )
    115132                                return result;
    116133                        }

  • src/ResolvExpr/ConversionCost.cc

    rb2fe1c9 r32cab5b  
    275275                        // xxx - not positive this is correct, but appears to allow casting int => enum
    276276                        cost = Cost::unsafe;
    277                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
    278                         cost = Cost::unsafe;
    279                 } // if
     277                } // if
     278                // no cases for zero_t/one_t because it should not be possible to convert int, etc. to zero_t/one_t.
    280279        }
    281280
    … …  
    309308                                // assignResult == 0 means Cost::Infinity
    310309                        } // if
    311                 } else if ( dynamic_cast< ZeroType * >( dest ) ) {
    312                         cost = Cost::unsafe;
     310                        // case case for zero_t because it should not be possible to convert pointers to zero_t.
    313311                } // if
    314312        }

  • src/ResolvExpr/Resolver.cc

    rb2fe1c9 r32cab5b  
    5959                void previsit( TypeDecl *typeDecl );
    6060                void previsit( EnumDecl * enumDecl );
     61                void previsit( StaticAssertDecl * assertDecl );
    6162
    6263                void previsit( ArrayType * at );
    … …  
    361362                GuardValue( inEnumDecl );
    362363                inEnumDecl = true;
     364        }
     365
     366        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
     367                findIntegralExpression( assertDecl->condition, indexer );
    363368        }
    364369

  • src/SymTab/Validate.cc

    rb2fe1c9 r32cab5b  
    8989                void previsit( StructDecl * aggregateDecl );
    9090                void previsit( UnionDecl * aggregateDecl );
     91                void previsit( StaticAssertDecl * assertDecl );
    9192
    9293          private:
    … …  
    147148                void previsit( ObjectDecl * object );
    148149                void previsit( FunctionDecl * func );
     150                void previsit( FunctionType * ftype );
    149151                void previsit( StructDecl * aggrDecl );
    150152                void previsit( UnionDecl * aggrDecl );
    … …  
    296298        }
    297299
    298         bool isStructOrUnion( Declaration *decl ) {
    299                 return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
     300        bool shouldHoist( Declaration *decl ) {
     301                return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl ) || dynamic_cast< StaticAssertDecl * >( decl );
    300302        }
    301303
    … …  
    310312                } // if
    311313                // Always remove the hoisted aggregate from the inner structure.
    312                 GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
     314                GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, shouldHoist, false ); } );
    313315        }
    314316
    … …  
    328330                if ( inst->baseUnion ) {
    329331                        declsToAddBefore.push_front( inst->baseUnion );
     332                }
     333        }
     334
     335        void HoistStruct::previsit( StaticAssertDecl * assertDecl ) {
     336                if ( parentAggr ) {
     337                        declsToAddBefore.push_back( assertDecl );
    330338                }
    331339        }
    … …  
    626634
    627635        void ForallPointerDecay::previsit( ObjectDecl *object ) {
    628                 forallFixer( object->type->forall, object );
    629                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
    630                         forallFixer( pointer->base->forall, object );
    631                 } // if
     636                // ensure that operator names only apply to functions or function pointers
     637                if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
     638                        SemanticError( object->location, toCString( "operator ", object->name.c_str(), " is not a function or function pointer." ) );
     639                }
    632640                object->fixUniqueId();
    633641        }
    634642
    635643        void ForallPointerDecay::previsit( FunctionDecl *func ) {
    636                 forallFixer( func->type->forall, func );
    637644                func->fixUniqueId();
     645        }
     646
     647        void ForallPointerDecay::previsit( FunctionType * ftype ) {
     648                forallFixer( ftype->forall, ftype );
    638649        }
    639650

  • src/SynTree/CompoundStmt.cc

    rb2fe1c9 r32cab5b  
    2323#include "Statement.h"                // for CompoundStmt, Statement, DeclStmt
    2424#include "SynTree/Label.h"            // for Label
    25 #include "SynTree/VarExprReplacer.h"  // for VarExprReplacer, VarExprReplace...
     25#include "SynTree/DeclReplacer.h"     // for DeclReplacer
    2626
    2727using std::string;
    … …  
    4949        // recursively execute this routine. There may be more efficient ways of doing
    5050        // this.
    51         VarExprReplacer::DeclMap declMap;
     51        DeclReplacer::DeclMap declMap;
    5252        std::list< Statement * >::const_iterator origit = other.kids.begin();
    5353        for ( Statement * s : kids ) {
    … …  
    6464        }
    6565        if ( ! declMap.empty() ) {
    66                 VarExprReplacer::replace( this, declMap );
     66                DeclReplacer::replace( this, declMap );
    6767        }
    6868}

  • src/SynTree/DeclReplacer.h

    rb2fe1c9 r32cab5b  
    2323class VariableExpr;
    2424
    25 namespace VarExprReplacer {
     25namespace DeclReplacer {
    2626        typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
     27        typedef std::map< TypeDecl *, TypeDecl * > TypeMap;
    2728
    2829        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
     30        void replace( BaseSyntaxNode * node, const TypeMap & typeMap, bool debug = false );
     31        void replace( BaseSyntaxNode * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
    2932}
    3033

  • src/SynTree/Declaration.cc

    rb2fe1c9 r32cab5b  
    8181
    8282
     83StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
     84}
     85
     86StaticAssertDecl::StaticAssertDecl( const StaticAssertDecl & other ) : Declaration( other ), condition( maybeClone( other.condition ) ), message( maybeClone( other.message ) )  {
     87}
     88
     89StaticAssertDecl::~StaticAssertDecl() {
     90        delete condition;
     91        delete message;
     92}
     93
     94void StaticAssertDecl::print( std::ostream &os, Indenter indent ) const {
     95        os << "Static Assert with condition: ";
     96        condition->print( os, indent+1 );
     97        os << std::endl << indent << "and message: ";
     98        message->print( os, indent+1 );
     99os << std::endl;
     100}
     101
     102void StaticAssertDecl::printShort( std::ostream &os, Indenter indent ) const {
     103        print( os, indent );
     104}
     105
    83106// Local Variables: //
    84107// tab-width: 4 //

  • src/SynTree/Declaration.h

    rb2fe1c9 r32cab5b  
    365365};
    366366
     367class StaticAssertDecl : public Declaration {
     368public:
     369        Expression * condition;
     370        ConstantExpr * message;   // string literal
     371
     372        StaticAssertDecl( Expression * condition, ConstantExpr * message );
     373        StaticAssertDecl( const StaticAssertDecl & other );
     374        virtual ~StaticAssertDecl();
     375
     376        virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
     377        virtual void accept( Visitor &v ) override { v.visit( this ); }
     378        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     379        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     380        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     381};
     382
    367383std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
    368384

  • src/SynTree/FunctionDecl.cc

    rb2fe1c9 r32cab5b  
    2626#include "Statement.h"           // for CompoundStmt
    2727#include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
    28 #include "VarExprReplacer.h"
     28#include "DeclReplacer.h"
    2929
    3030extern bool translation_unit_nomain;
    … …  
    4141                : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
    4242
    43         VarExprReplacer::DeclMap declMap;
     43        DeclReplacer::DeclMap declMap;
    4444        for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
    4545                declMap[ std::get<0>(p) ] = std::get<1>(p);
    … …  
    4949        }
    5050        if ( ! declMap.empty() ) {
    51                 VarExprReplacer::replace( this, declMap );
     51                DeclReplacer::replace( this, declMap );
    5252        }
    5353        cloneAll( other.withExprs, withExprs );

  • src/SynTree/Mutator.h

    rb2fe1c9 r32cab5b  
    3434        virtual Declaration * mutate( TypedefDecl * typeDecl ) = 0;
    3535        virtual AsmDecl * mutate( AsmDecl * asmDecl ) = 0;
     36        virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
    3637
    3738        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;

  • src/SynTree/Statement.cc

    rb2fe1c9 r32cab5b  
    3434Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
    3535
    36 void Statement::print( std::ostream & os, Indenter ) const {
     36void Statement::print( std::ostream & os, Indenter indent ) const {
    3737        if ( ! labels.empty() ) {
    38                 os << "Labels: {";
     38                os << indent << "... Labels: {";
    3939                for ( const Label & l : labels ) {
    4040                        os << l << ",";
    … …  
    223223
    224224void CaseStmt::print( std::ostream &os, Indenter indent ) const {
    225         if ( isDefault() ) os << "Default ";
     225        if ( isDefault() ) os << indent << "Default ";
    226226        else {
    227                 os << "Case ";
     227                os << indent << "Case ";
    228228                condition->print( os, indent );
    229229        } // if
    … …  
    231231
    232232        for ( Statement * stmt : stmts ) {
     233                os << indent+1;
    233234                stmt->print( os, indent+1 );
    234235        }
    … …  
    478479}
    479480
    480 void NullStmt::print( std::ostream &os, Indenter ) const {
     481void NullStmt::print( std::ostream &os, Indenter indent ) const {
    481482        os << "Null Statement" << endl;
     483        Statement::print( os, indent );
    482484}
    483485

  • src/SynTree/Statement.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Sep  3 20:46:46 2017
    13 // Update Count     : 77
     12// Last Modified On : Thu Mar  8 14:53:02 2018
     13// Update Count     : 78
    1414//
    1515
    … …  
    255255class BranchStmt : public Statement {
    256256  public:
    257         enum Type { Goto = 0, Break, Continue };
     257        enum Type { Goto = 0, Break, Continue, FallThrough, FallThroughDefault };
    258258
    259259        // originalTarget kept for error messages.

  • src/SynTree/SynTree.h

    rb2fe1c9 r32cab5b  
    3838class TypedefDecl;
    3939class AsmDecl;
     40class StaticAssertDecl;
    4041
    4142class Statement;

  • src/SynTree/TypeSubstitution.cc

    rb2fe1c9 r32cab5b  
    149149                return inst;
    150150        } else {
    151 ///         std::cerr << "found " << inst->get_name() << ", replacing with ";
    152 ///         i->second->print( std::cerr );
    153 ///         std::cerr << std::endl;
     151                // cut off infinite loop for the case where a type is bound to itself.
     152                // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
     153                // TODO: investigate preventing type variables from being bound to themselves in the first place.
     154                if ( TypeInstType * replacement = dynamic_cast< TypeInstType * >( i->second ) ) {
     155                        if ( inst->name == replacement->name ) {
     156                                return inst;
     157                        }
     158                }
     159                // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
    154160                subCount++;
    155161                Type * newtype = i->second->clone();
    156162                newtype->get_qualifiers() |= inst->get_qualifiers();
    157163                delete inst;
    158                 return newtype;
     164                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
     165                return newtype->acceptMutator( *visitor );
    159166        } // if
    160167}

  • src/SynTree/TypeSubstitution.h

    rb2fe1c9 r32cab5b  
    129129
    130130// definitition must happen after PassVisitor is included so that WithGuards can be used
    131 struct TypeSubstitution::Substituter : public WithGuards {
     131struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
    132132                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
    133133

  • src/SynTree/Visitor.h

    rb2fe1c9 r32cab5b  
    3636        virtual void visit( TypedefDecl * typeDecl ) = 0;
    3737        virtual void visit( AsmDecl * asmDecl ) = 0;
     38        virtual void visit( StaticAssertDecl * assertDecl ) = 0;
    3839
    3940        virtual void visit( CompoundStmt * compoundStmt ) = 0;

  • src/SynTree/module.mk

    rb2fe1c9 r32cab5b  
    4848       SynTree/TypeSubstitution.cc \
    4949       SynTree/Attribute.cc \
    50        SynTree/VarExprReplacer.cc
     50       SynTree/DeclReplacer.cc
    5151

  • src/benchmark/bench.h

    rb2fe1c9 r32cab5b  
    1010#if defined(__cforall)
    1111}
    12 #include <bits/cfatime.h>
     12//#include <bits/cfatime.h>
    1313#endif
    1414

  • src/libcfa/Makefile.am

    rb2fe1c9 r32cab5b  
    1111## Created On       : Sun May 31 08:54:01 2015
    1212## Last Modified By : Peter A. Buhr
    13 ## Last Modified On : Fri Feb  9 15:51:24 2018
    14 ## Update Count     : 223
     13## Last Modified On : Thu Apr 12 14:38:34 2018
     14## Update Count     : 231
    1515###############################################################################
    1616
    … …  
    4646CC = ${abs_top_srcdir}/src/driver/cfa
    4747
    48 headers = fstream iostream iterator limits rational stdlib \
     48headers = fstream iostream iterator limits rational time stdlib \
    4949          containers/maybe containers/pair containers/result containers/vector
    5050
    … …  
    100100        math                            \
    101101        gmp                             \
     102        time_t.h                        \
     103        clock                   \
    102104        bits/align.h            \
    103         bits/cfatime.h          \
    104105        bits/containers.h               \
    105106        bits/defs.h             \

  • src/libcfa/Makefile.in

    rb2fe1c9 r32cab5b  
    150150am__libcfa_d_a_SOURCES_DIST = libcfa-prelude.c interpose.c \
    151151        bits/debug.c fstream.c iostream.c iterator.c limits.c \
    152         rational.c stdlib.c containers/maybe.c containers/pair.c \
    153         containers/result.c containers/vector.c \
     152        rational.c time.c stdlib.c containers/maybe.c \
     153        containers/pair.c containers/result.c containers/vector.c \
    154154        concurrency/coroutine.c concurrency/thread.c \
    155155        concurrency/kernel.c concurrency/monitor.c assert.c \
    … …  
    165165        libcfa_d_a-iostream.$(OBJEXT) libcfa_d_a-iterator.$(OBJEXT) \
    166166        libcfa_d_a-limits.$(OBJEXT) libcfa_d_a-rational.$(OBJEXT) \
    167         libcfa_d_a-stdlib.$(OBJEXT) \
     167        libcfa_d_a-time.$(OBJEXT) libcfa_d_a-stdlib.$(OBJEXT) \
    168168        containers/libcfa_d_a-maybe.$(OBJEXT) \
    169169        containers/libcfa_d_a-pair.$(OBJEXT) \
    … …  
    184184libcfa_a_LIBADD =
    185185am__libcfa_a_SOURCES_DIST = libcfa-prelude.c interpose.c bits/debug.c \
    186         fstream.c iostream.c iterator.c limits.c rational.c stdlib.c \
    187         containers/maybe.c containers/pair.c containers/result.c \
    188         containers/vector.c concurrency/coroutine.c \
    189         concurrency/thread.c concurrency/kernel.c \
    190         concurrency/monitor.c assert.c exception.c virtual.c \
    191         concurrency/CtxSwitch-@MACHINE_TYPE@.S concurrency/alarm.c \
    192         concurrency/invoke.c concurrency/preemption.c
     186        fstream.c iostream.c iterator.c limits.c rational.c time.c \
     187        stdlib.c containers/maybe.c containers/pair.c \
     188        containers/result.c containers/vector.c \
     189        concurrency/coroutine.c concurrency/thread.c \
     190        concurrency/kernel.c concurrency/monitor.c assert.c \
     191        exception.c virtual.c concurrency/CtxSwitch-@MACHINE_TYPE@.S \
     192        concurrency/alarm.c concurrency/invoke.c \
     193        concurrency/preemption.c
    193194@BUILD_CONCURRENCY_TRUE@am__objects_5 = concurrency/libcfa_a-coroutine.$(OBJEXT) \
    194195@BUILD_CONCURRENCY_TRUE@        concurrency/libcfa_a-thread.$(OBJEXT) \
    … …  
    197198am__objects_6 = libcfa_a-fstream.$(OBJEXT) libcfa_a-iostream.$(OBJEXT) \
    198199        libcfa_a-iterator.$(OBJEXT) libcfa_a-limits.$(OBJEXT) \
    199         libcfa_a-rational.$(OBJEXT) libcfa_a-stdlib.$(OBJEXT) \
    200         containers/libcfa_a-maybe.$(OBJEXT) \
     200        libcfa_a-rational.$(OBJEXT) libcfa_a-time.$(OBJEXT) \
     201        libcfa_a-stdlib.$(OBJEXT) containers/libcfa_a-maybe.$(OBJEXT) \
    201202        containers/libcfa_a-pair.$(OBJEXT) \
    202203        containers/libcfa_a-result.$(OBJEXT) \
    … …  
    260261  esac
    261262am__nobase_cfa_include_HEADERS_DIST = fstream iostream iterator limits \
    262         rational stdlib containers/maybe containers/pair \
     263        rational time stdlib containers/maybe containers/pair \
    263264        containers/result containers/vector concurrency/coroutine \
    264265        concurrency/thread concurrency/kernel concurrency/monitor \
    265         ${shell find stdhdr -type f -printf "%p "} math gmp \
    266         bits/align.h bits/cfatime.h bits/containers.h bits/defs.h \
    267         bits/debug.h bits/locks.h concurrency/invoke.h
     266        ${shell find stdhdr -type f -printf "%p "} math gmp time_t.h \
     267        clock bits/align.h bits/containers.h bits/defs.h bits/debug.h \
     268        bits/locks.h concurrency/invoke.h
    268269HEADERS = $(nobase_cfa_include_HEADERS)
    269270am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
    … …  
    419420EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
    420421AM_CCASFLAGS = @CFA_FLAGS@
    421 headers = fstream iostream iterator limits rational stdlib \
     422headers = fstream iostream iterator limits rational time stdlib \
    422423        containers/maybe containers/pair containers/result \
    423424        containers/vector $(am__append_3)
    … …  
    436437        math                            \
    437438        gmp                             \
     439        time_t.h                        \
     440        clock                   \
    438441        bits/align.h            \
    439         bits/cfatime.h          \
    440442        bits/containers.h               \
    441443        bits/defs.h             \
    … …  
    611613@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-rational.Po@am__quote@
    612614@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-stdlib.Po@am__quote@
     615@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-time.Po@am__quote@
    613616@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_a-virtual.Po@am__quote@
    614617@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-assert.Po@am__quote@
    … …  
    622625@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-rational.Po@am__quote@
    623626@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-stdlib.Po@am__quote@
     627@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-time.Po@am__quote@
    624628@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libcfa_d_a-virtual.Po@am__quote@
    625629@AMDEP_TRUE@@am__include@ @am__quote@bits/$(DEPDIR)/libcfa_a-debug.Po@am__quote@
    … …  
    786790@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
    787791
     792libcfa_d_a-time.o: time.c
     793@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-time.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-time.Tpo -c -o libcfa_d_a-time.o `test -f 'time.c' || echo '$(srcdir)/'`time.c
     794@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-time.Tpo $(DEPDIR)/libcfa_d_a-time.Po
     795@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='time.c' object='libcfa_d_a-time.o' libtool=no @AMDEPBACKSLASH@
     796@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     797@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-time.o `test -f 'time.c' || echo '$(srcdir)/'`time.c
     798
     799libcfa_d_a-time.obj: time.c
     800@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-time.obj -MD -MP -MF $(DEPDIR)/libcfa_d_a-time.Tpo -c -o libcfa_d_a-time.obj `if test -f 'time.c'; then $(CYGPATH_W) 'time.c'; else $(CYGPATH_W) '$(srcdir)/time.c'; fi`
     801@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_d_a-time.Tpo $(DEPDIR)/libcfa_d_a-time.Po
     802@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='time.c' object='libcfa_d_a-time.obj' libtool=no @AMDEPBACKSLASH@
     803@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     804@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -c -o libcfa_d_a-time.obj `if test -f 'time.c'; then $(CYGPATH_W) 'time.c'; else $(CYGPATH_W) '$(srcdir)/time.c'; fi`
     805
    788806libcfa_d_a-stdlib.o: stdlib.c
    789807@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_d_a_CFLAGS) $(CFLAGS) -MT libcfa_d_a-stdlib.o -MD -MP -MF $(DEPDIR)/libcfa_d_a-stdlib.Tpo -c -o libcfa_d_a-stdlib.o `test -f 'stdlib.c' || echo '$(srcdir)/'`stdlib.c
    … …  
    10791097@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    10801098@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-rational.obj `if test -f 'rational.c'; then $(CYGPATH_W) 'rational.c'; else $(CYGPATH_W) '$(srcdir)/rational.c'; fi`
     1099
     1100libcfa_a-time.o: time.c
     1101@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-time.o -MD -MP -MF $(DEPDIR)/libcfa_a-time.Tpo -c -o libcfa_a-time.o `test -f 'time.c' || echo '$(srcdir)/'`time.c
     1102@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-time.Tpo $(DEPDIR)/libcfa_a-time.Po
     1103@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='time.c' object='libcfa_a-time.o' libtool=no @AMDEPBACKSLASH@
     1104@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1105@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-time.o `test -f 'time.c' || echo '$(srcdir)/'`time.c
     1106
     1107libcfa_a-time.obj: time.c
     1108@am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -MT libcfa_a-time.obj -MD -MP -MF $(DEPDIR)/libcfa_a-time.Tpo -c -o libcfa_a-time.obj `if test -f 'time.c'; then $(CYGPATH_W) 'time.c'; else $(CYGPATH_W) '$(srcdir)/time.c'; fi`
     1109@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/libcfa_a-time.Tpo $(DEPDIR)/libcfa_a-time.Po
     1110@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='time.c' object='libcfa_a-time.obj' libtool=no @AMDEPBACKSLASH@
     1111@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1112@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libcfa_a_CFLAGS) $(CFLAGS) -c -o libcfa_a-time.obj `if test -f 'time.c'; then $(CYGPATH_W) 'time.c'; else $(CYGPATH_W) '$(srcdir)/time.c'; fi`
    10811113
    10821114libcfa_a-stdlib.o: stdlib.c

  • src/libcfa/bits/locks.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Oct 31 15:14:38 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Dec  8 16:02:22 2017
    13 // Update Count     : 1
     12// Last Modified On : Fri Mar 30 18:18:13 2018
     13// Update Count     : 9
    1414//
    1515
    … …  
    6464
    6565        extern void yield( unsigned int );
    66         extern thread_local struct thread_desc *    volatile this_thread;
    67         extern thread_local struct processor *      volatile this_processor;
    6866
    6967        static inline void ?{}( __spinlock_t & this ) {
    … …  
    7674                if( result ) {
    7775                        disable_interrupts();
    78                         __cfaabi_dbg_debug_do(
    79                                 this.prev_name = caller;
    80                                 this.prev_thrd = this_thread;
    81                         )
     76                        // __cfaabi_dbg_debug_do(
     77                        //      this.prev_name = caller;
     78                        //      this.prev_thrd = TL_GET( this_thread );
     79                        // )
    8280                }
    8381                return result;
    … …  
    107105                }
    108106                disable_interrupts();
    109                 __cfaabi_dbg_debug_do(
    110                         this.prev_name = caller;
    111                         this.prev_thrd = this_thread;
    112                 )
     107                // __cfaabi_dbg_debug_do(
     108                //      this.prev_name = caller;
     109                //      this.prev_thrd = TL_GET( this_thread );
     110                // )
    113111        }
    114112

  • src/libcfa/concurrency/alarm.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Fri Jun 2 11:31:25 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 21 22:35:18 2017
    13 // Update Count     : 1
     12// Last Modified On : Mon Apr  9 13:36:18 2018
     13// Update Count     : 61
    1414//
    1515
    … …  
    2626#include "preemption.h"
    2727
    28 
    29 static inline void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) {
    30         it_value.tv_sec = alarm->val / (1`cfa_s).val;                   // seconds
    31         it_value.tv_usec = max( (alarm->val % (1`cfa_s).val) / (1`cfa_us).val, 1000 ); // microseconds
    32         it_interval.tv_sec = 0;
    33         it_interval.tv_usec = 0;
    34 }
    35 
    36 static inline void ?{}( __cfa_time_t & this, timespec * curr ) {
    37         uint64_t secs  = curr->tv_sec;
    38         uint64_t nsecs = curr->tv_nsec;
    39         this.val = from_s(secs).val + nsecs;
    40 }
    41 
    4228//=============================================================================================
    4329// Clock logic
    4430//=============================================================================================
    4531
    46 __cfa_time_t __kernel_get_time() {
     32Time __kernel_get_time() {
    4733        timespec curr;
    48         clock_gettime( CLOCK_REALTIME, &curr );
    49         return (__cfa_time_t){ &curr };
     34        clock_gettime( CLOCK_MONOTONIC_RAW, &curr );            // CLOCK_REALTIME
     35        return (Time){ curr };
    5036}
    5137
    52 void __kernel_set_timer( __cfa_time_t alarm ) {
    53         itimerval val = { &alarm };
    54         setitimer( ITIMER_REAL, &val, NULL );
     38void __kernel_set_timer( Duration alarm ) {
     39        setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL );
    5540}
    5641
    … …  
    5944//=============================================================================================
    6045
    61 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
     46void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period ) with( this ) {
    6247        this.thrd = thrd;
    6348        this.alarm = alarm;
    … …  
    6853}
    6954
    70 void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
     55void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period ) with( this ) {
    7156        this.proc = proc;
    7257        this.alarm = alarm;

  • src/libcfa/concurrency/alarm.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Fri Jun 2 11:31:25 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:59:27 2017
    13 // Update Count     : 3
     12// Last Modified On : Mon Mar 26 16:25:41 2018
     13// Update Count     : 11
    1414//
    1515
    … …  
    2121#include <assert.h>
    2222
    23 #include "bits/cfatime.h"
     23#include "time"
    2424
    2525struct thread_desc;
    … …  
    3030//=============================================================================================
    3131
    32 __cfa_time_t __kernel_get_time();
    33 void __kernel_set_timer( __cfa_time_t alarm );
     32Time __kernel_get_time();
     33void __kernel_set_timer( Duration alarm );
    3434
    3535//=============================================================================================
    … …  
    3838
    3939struct alarm_node_t {
    40         __cfa_time_t alarm;             // time when alarm goes off
    41         __cfa_time_t period;            // if > 0 => period of alarm
     40        Time alarm;                             // time when alarm goes off
     41        Duration period;                        // if > 0 => period of alarm
    4242        alarm_node_t * next;            // intrusive link list field
    4343
    … …  
    5353typedef alarm_node_t ** __alarm_it_t;
    5454
    55 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
    56 void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
     55void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
     56void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
    5757void ^?{}( alarm_node_t & this );
    5858

  • src/libcfa/concurrency/coroutine

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 30 07:58:29 2017
    13 // Update Count     : 3
     12// Last Modified On : Fri Mar 30 18:23:45 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    6060}
    6161
    62 // Get current coroutine
    63 extern thread_local coroutine_desc * volatile this_coroutine;
    64 
    6562// Private wrappers for context switch and stack creation
    6663extern void CoroutineCtxSwitch(coroutine_desc * src, coroutine_desc * dst);
    … …  
    6966// Suspend implementation inlined for performance
    7067static inline void suspend() {
    71         coroutine_desc * src = this_coroutine;          // optimization
     68        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
    7269
    7370        assertf( src->last != 0,
    … …  
    8683forall(dtype T | is_coroutine(T))
    8784static inline void resume(T & cor) {
    88         coroutine_desc * src = this_coroutine;          // optimization
     85        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
    8986        coroutine_desc * dst = get_coroutine(cor);
    9087
    … …  
    111108
    112109static inline void resume(coroutine_desc * dst) {
    113         coroutine_desc * src = this_coroutine;          // optimization
     110        coroutine_desc * src = TL_GET( this_coroutine );                        // optimization
    114111
    115112        // not resuming self ?

  • src/libcfa/concurrency/coroutine.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon Nov 28 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  8 16:10:31 2018
    13 // Update Count     : 4
     12// Last Modified On : Fri Mar 30 17:20:57 2018
     13// Update Count     : 9
    1414//
    1515
    … …  
    9999// Wrapper for co
    100100void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) {
    101         verify( preemption_state.enabled || this_processor->do_terminate );
     101        verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
    102102        disable_interrupts();
    103103
    … …  
    106106
    107107        // set new coroutine that task is executing
    108         this_coroutine = dst;
     108        TL_SET( this_coroutine, dst );
    109109
    110110        // context switch to specified coroutine
    … …  
    117117
    118118        enable_interrupts( __cfaabi_dbg_ctx );
    119         verify( preemption_state.enabled || this_processor->do_terminate );
     119        verify( TL_GET( preemption_state ).enabled || TL_GET( this_processor )->do_terminate );
    120120} //ctxSwitchDirect
    121121
    … …  
    172172
    173173        void __leave_coroutine(void) {
    174                 coroutine_desc * src = this_coroutine;          // optimization
     174                coroutine_desc * src = TL_GET( this_coroutine ); // optimization
    175175
    176176                assertf( src->starter != 0,

  • src/libcfa/concurrency/invoke.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Jan 17 12:27:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  9 14:41:55 2018
    13 // Update Count     : 6
     12// Last Modified On : Fri Mar 30 22:33:59 2018
     13// Update Count     : 30
    1414//
    1515
    … …  
    1717#include "bits/defs.h"
    1818#include "bits/locks.h"
     19
     20#define TL_GET( member ) kernelThreadData.member
     21#define TL_SET( member, value ) kernelThreadData.member = value;
    1922
    2023#ifdef __cforall
    … …  
    3033                static inline struct thread_desc             * & get_next( struct thread_desc             & this );
    3134                static inline struct __condition_criterion_t * & get_next( struct __condition_criterion_t & this );
     35
     36                extern thread_local struct KernelThreadData {
     37                        struct coroutine_desc * volatile this_coroutine;
     38                        struct thread_desc    * volatile this_thread;
     39                        struct processor      * volatile this_processor;
     40
     41                        struct {
     42                                volatile unsigned short disable_count;
     43                                volatile bool enabled;
     44                                volatile bool in_progress;
     45                        } preemption_state;
     46                } kernelThreadData;
    3247        }
     48
     49        static inline struct coroutine_desc * volatile active_coroutine() { return TL_GET( this_coroutine ); }
     50        static inline struct thread_desc * volatile active_thread() { return TL_GET( this_thread ); }
     51        static inline struct processor * volatile active_processor() { return TL_GET( this_processor ); }
    3352        #endif
    3453
    3554        struct coStack_t {
    36                 // size of stack
    37                 size_t size;
    38 
    39                 // pointer to stack
    40                 void *storage;
    41 
    42                 // stack grows towards stack limit
    43                 void *limit;
    44 
    45                 // base of stack
    46                 void *base;
    47 
    48                 // address of cfa_context_t
    49                 void *context;
    50 
    51                 // address of top of storage
    52                 void *top;
    53 
    54                 // whether or not the user allocated the stack
    55                 bool userStack;
     55                size_t size;                                                                    // size of stack
     56                void * storage;                                                                 // pointer to stack
     57                void * limit;                                                                   // stack grows towards stack limit
     58                void * base;                                                                    // base of stack
     59                void * context;                                                                 // address of cfa_context_t
     60                void * top;                                                                             // address of top of storage
     61                bool userStack;                                                                 // whether or not the user allocated the stack
    5662        };
    5763
    … …  
    5965
    6066        struct coroutine_desc {
    61                 // stack information of the coroutine
    62                 struct coStack_t stack;
    63 
    64                 // textual name for coroutine/task, initialized by uC++ generated code
    65                 const char *name;
    66 
    67                 // copy of global UNIX variable errno
    68                 int errno_;
    69 
    70                 // current execution status for coroutine
    71                 enum coroutine_state state;
    72 
    73                 // first coroutine to resume this one
    74                 struct coroutine_desc * starter;
    75 
    76                 // last coroutine to resume this one
    77                 struct coroutine_desc * last;
     67                struct coStack_t stack;                                                 // stack information of the coroutine
     68                const char * name;                                                              // textual name for coroutine/task, initialized by uC++ generated code
     69                int errno_;                                                                             // copy of global UNIX variable errno
     70                enum coroutine_state state;                                             // current execution status for coroutine
     71                struct coroutine_desc * starter;                                // first coroutine to resume this one
     72                struct coroutine_desc * last;                                   // last coroutine to resume this one
    7873        };
    7974

  • src/libcfa/concurrency/kernel

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:58:39 2017
    13 // Update Count     : 2
     12// Last Modified On : Tue Apr 10 14:46:49 2018
     13// Update Count     : 10
    1414//
    1515
    … …  
    1919
    2020#include "invoke.h"
    21 #include "bits/cfatime.h"
     21#include "time_t.h"
    2222
    2323extern "C" {
    … …  
    4949
    5050        // Preemption rate on this cluster
    51         __cfa_time_t preemption_rate;
     51        Duration preemption_rate;
    5252};
    5353
    54 extern __cfa_time_t default_preemption();
     54extern Duration default_preemption();
    5555
    5656void ?{} (cluster & this);

  • src/libcfa/concurrency/kernel.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb  8 23:52:19 2018
    13 // Update Count     : 5
     12// Last Modified On : Mon Apr  9 16:11:46 2018
     13// Update Count     : 24
    1414//
    1515
    … …  
    2525
    2626//CFA Includes
     27#include "time"
    2728#include "kernel_private.h"
    2829#include "preemption.h"
    … …  
    5253// Global state
    5354
    54 thread_local coroutine_desc * volatile this_coroutine;
    55 thread_local thread_desc *    volatile this_thread;
    56 thread_local processor *      volatile this_processor;
    57 
    5855// volatile thread_local bool preemption_in_progress = 0;
    5956// volatile thread_local bool preemption_enabled = false;
    6057// volatile thread_local unsigned short disable_preempt_count = 1;
    6158
    62 volatile thread_local __cfa_kernel_preemption_state_t preemption_state = { false, false, 1 };
     59thread_local struct KernelThreadData kernelThreadData = {
     60        NULL,
     61        NULL,
     62        NULL,
     63        { 1, false, false }
     64};
    6365
    6466//-----------------------------------------------------------------------------
    … …  
    172174                terminate(&this);
    173175                verify(this.do_terminate);
    174                 verify(this_processor != &this);
     176                verify(TL_GET( this_processor ) != &this);
    175177                P( terminated );
    176                 verify(this_processor != &this);
     178                verify(TL_GET( this_processor ) != &this);
    177179                pthread_join( kernel_thread, NULL );
    178180        }
    … …  
    213215                        if(readyThread)
    214216                        {
    215                                 verify( !preemption_state.enabled );
     217                                verify( ! TL_GET( preemption_state ).enabled );
    216218
    217219                                runThread(this, readyThread);
    218220
    219                                 verify( !preemption_state.enabled );
     221                                verify( ! TL_GET( preemption_state ).enabled );
    220222
    221223                                //Some actions need to be taken from the kernel
    … …  
    249251
    250252        //Update global state
    251         this_thread = dst;
     253        TL_SET( this_thread, dst );
    252254
    253255        // Context Switch to the thread
    … …  
    257259
    258260void returnToKernel() {
    259         coroutine_desc * proc_cor = get_coroutine(this_processor->runner);
    260         coroutine_desc * thrd_cor = this_thread->curr_cor = this_coroutine;
     261        coroutine_desc * proc_cor = get_coroutine(TL_GET( this_processor )->runner);
     262        coroutine_desc * thrd_cor = TL_GET( this_thread )->curr_cor = TL_GET( this_coroutine );
    261263        ThreadCtxSwitch(thrd_cor, proc_cor);
    262264}
    … …  
    266268void finishRunning(processor * this) with( this->finish ) {
    267269        if( action_code == Release ) {
    268                 verify( !preemption_state.enabled );
     270                verify( ! TL_GET( preemption_state ).enabled );
    269271                unlock( *lock );
    270272        }
    … …  
    273275        }
    274276        else if( action_code == Release_Schedule ) {
    275                 verify( !preemption_state.enabled );
     277                verify( ! TL_GET( preemption_state ).enabled );
    276278                unlock( *lock );
    277279                ScheduleThread( thrd );
    278280        }
    279281        else if( action_code == Release_Multi ) {
    280                 verify( !preemption_state.enabled );
     282                verify( ! TL_GET( preemption_state ).enabled );
    281283                for(int i = 0; i < lock_count; i++) {
    282284                        unlock( *locks[i] );
    … …  
    307309void * CtxInvokeProcessor(void * arg) {
    308310        processor * proc = (processor *) arg;
    309         this_processor = proc;
    310         this_coroutine = NULL;
    311         this_thread = NULL;
    312         preemption_state.enabled = false;
    313         preemption_state.disable_count = 1;
     311        TL_SET( this_processor, proc );
     312        TL_SET( this_coroutine, NULL );
     313        TL_SET( this_thread, NULL );
     314        TL_GET( preemption_state ).enabled = false;
     315        TL_GET( preemption_state ).disable_count = 1;
    314316        // SKULLDUGGERY: We want to create a context for the processor coroutine
    315317        // which is needed for the 2-step context switch. However, there is no reason
    … …  
    323325
    324326        //Set global state
    325         this_coroutine = get_coroutine(proc->runner);
    326         this_thread = NULL;
     327        TL_SET( this_coroutine, get_coroutine(proc->runner) );
     328        TL_SET( this_thread, NULL );
    327329
    328330        //We now have a proper context from which to schedule threads
    … …  
    352354
    353355void kernel_first_resume(processor * this) {
    354         coroutine_desc * src = this_coroutine;
     356        coroutine_desc * src = TL_GET( this_coroutine );
    355357        coroutine_desc * dst = get_coroutine(this->runner);
    356358
    357         verify( !preemption_state.enabled );
     359        verify( ! TL_GET( preemption_state ).enabled );
    358360
    359361        create_stack(&dst->stack, dst->stack.size);
    360362        CtxStart(&this->runner, CtxInvokeCoroutine);
    361363
    362         verify( !preemption_state.enabled );
     364        verify( ! TL_GET( preemption_state ).enabled );
    363365
    364366        dst->last = src;
    … …  
    369371
    370372        // set new coroutine that task is executing
    371         this_coroutine = dst;
     373        TL_SET( this_coroutine, dst );
    372374
    373375        // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
    … …  
    386388        src->state = Active;
    387389
    388         verify( !preemption_state.enabled );
     390        verify( ! TL_GET( preemption_state ).enabled );
    389391}
    390392
    … …  
    392394// Scheduler routines
    393395void ScheduleThread( thread_desc * thrd ) {
    394         // if( !thrd ) return;
     396        // if( ! thrd ) return;
    395397        verify( thrd );
    396398        verify( thrd->self_cor.state != Halted );
    397399
    398         verify( !preemption_state.enabled );
     400        verify( ! TL_GET( preemption_state ).enabled );
    399401
    400402        verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
    401403
    402         with( *this_processor->cltr ) {
     404        with( *TL_GET( this_processor )->cltr ) {
    403405                lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
    404406                append( ready_queue, thrd );
    … …  
    406408        }
    407409
    408         verify( !preemption_state.enabled );
     410        verify( ! TL_GET( preemption_state ).enabled );
    409411}
    410412
    411413thread_desc * nextThread(cluster * this) with( *this ) {
    412         verify( !preemption_state.enabled );
     414        verify( ! TL_GET( preemption_state ).enabled );
    413415        lock( ready_queue_lock __cfaabi_dbg_ctx2 );
    414416        thread_desc * head = pop_head( ready_queue );
    415417        unlock( ready_queue_lock );
    416         verify( !preemption_state.enabled );
     418        verify( ! TL_GET( preemption_state ).enabled );
    417419        return head;
    418420}
    … …  
    420422void BlockInternal() {
    421423        disable_interrupts();
    422         verify( !preemption_state.enabled );
     424        verify( ! TL_GET( preemption_state ).enabled );
    423425        returnToKernel();
    424         verify( !preemption_state.enabled );
     426        verify( ! TL_GET( preemption_state ).enabled );
    425427        enable_interrupts( __cfaabi_dbg_ctx );
    426428}
    … …  
    428430void BlockInternal( __spinlock_t * lock ) {
    429431        disable_interrupts();
    430         this_processor->finish.action_code = Release;
    431         this_processor->finish.lock        = lock;
    432 
    433         verify( !preemption_state.enabled );
     432        TL_GET( this_processor )->finish.action_code = Release;
     433        TL_GET( this_processor )->finish.lock        = lock;
     434
     435        verify( ! TL_GET( preemption_state ).enabled );
    434436        returnToKernel();
    435         verify( !preemption_state.enabled );
     437        verify( ! TL_GET( preemption_state ).enabled );
    436438
    437439        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    440442void BlockInternal( thread_desc * thrd ) {
    441443        disable_interrupts();
    442         this_processor->finish.action_code = Schedule;
    443         this_processor->finish.thrd        = thrd;
    444 
    445         verify( !preemption_state.enabled );
     444        TL_GET( this_processor )->finish.action_code = Schedule;
     445        TL_GET( this_processor )->finish.thrd        = thrd;
     446
     447        verify( ! TL_GET( preemption_state ).enabled );
    446448        returnToKernel();
    447         verify( !preemption_state.enabled );
     449        verify( ! TL_GET( preemption_state ).enabled );
    448450
    449451        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    453455        assert(thrd);
    454456        disable_interrupts();
    455         this_processor->finish.action_code = Release_Schedule;
    456         this_processor->finish.lock        = lock;
    457         this_processor->finish.thrd        = thrd;
    458 
    459         verify( !preemption_state.enabled );
     457        TL_GET( this_processor )->finish.action_code = Release_Schedule;
     458        TL_GET( this_processor )->finish.lock        = lock;
     459        TL_GET( this_processor )->finish.thrd        = thrd;
     460
     461        verify( ! TL_GET( preemption_state ).enabled );
    460462        returnToKernel();
    461         verify( !preemption_state.enabled );
     463        verify( ! TL_GET( preemption_state ).enabled );
    462464
    463465        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    466468void BlockInternal(__spinlock_t * locks [], unsigned short count) {
    467469        disable_interrupts();
    468         this_processor->finish.action_code = Release_Multi;
    469         this_processor->finish.locks       = locks;
    470         this_processor->finish.lock_count  = count;
    471 
    472         verify( !preemption_state.enabled );
     470        TL_GET( this_processor )->finish.action_code = Release_Multi;
     471        TL_GET( this_processor )->finish.locks       = locks;
     472        TL_GET( this_processor )->finish.lock_count  = count;
     473
     474        verify( ! TL_GET( preemption_state ).enabled );
    473475        returnToKernel();
    474         verify( !preemption_state.enabled );
     476        verify( ! TL_GET( preemption_state ).enabled );
    475477
    476478        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    479481void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
    480482        disable_interrupts();
    481         this_processor->finish.action_code = Release_Multi_Schedule;
    482         this_processor->finish.locks       = locks;
    483         this_processor->finish.lock_count  = lock_count;
    484         this_processor->finish.thrds       = thrds;
    485         this_processor->finish.thrd_count  = thrd_count;
    486 
    487         verify( !preemption_state.enabled );
     483        TL_GET( this_processor )->finish.action_code = Release_Multi_Schedule;
     484        TL_GET( this_processor )->finish.locks       = locks;
     485        TL_GET( this_processor )->finish.lock_count  = lock_count;
     486        TL_GET( this_processor )->finish.thrds       = thrds;
     487        TL_GET( this_processor )->finish.thrd_count  = thrd_count;
     488
     489        verify( ! TL_GET( preemption_state ).enabled );
    488490        returnToKernel();
    489         verify( !preemption_state.enabled );
     491        verify( ! TL_GET( preemption_state ).enabled );
    490492
    491493        enable_interrupts( __cfaabi_dbg_ctx );
    … …  
    493495
    494496void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
    495         verify( !preemption_state.enabled );
    496         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
    497         this_processor->finish.lock        = lock;
    498         this_processor->finish.thrd        = thrd;
     497        verify( ! TL_GET( preemption_state ).enabled );
     498        TL_GET( this_processor )->finish.action_code = thrd ? Release_Schedule : Release;
     499        TL_GET( this_processor )->finish.lock        = lock;
     500        TL_GET( this_processor )->finish.thrd        = thrd;
    499501
    500502        returnToKernel();
    … …  
    507509// Kernel boot procedures
    508510void kernel_startup(void) {
    509         verify( !preemption_state.enabled );
     511        verify( ! TL_GET( preemption_state ).enabled );
    510512        __cfaabi_dbg_print_safe("Kernel : Starting\n");
    511513
    … …  
    531533
    532534        //initialize the global state variables
    533         this_processor = mainProcessor;
    534         this_thread = mainThread;
    535         this_coroutine = &mainThread->self_cor;
     535        TL_SET( this_processor, mainProcessor );
     536        TL_SET( this_thread, mainThread );
     537        TL_SET( this_coroutine, &mainThread->self_cor );
    536538
    537539        // Enable preemption
    … …  
    545547        // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
    546548        // mainThread is on the ready queue when this call is made.
    547         kernel_first_resume( this_processor );
     549        kernel_first_resume( TL_GET( this_processor ) );
    548550
    549551
    … …  
    552554        __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
    553555
    554         verify( !preemption_state.enabled );
     556        verify( ! TL_GET( preemption_state ).enabled );
    555557        enable_interrupts( __cfaabi_dbg_ctx );
    556         verify( preemption_state.enabled );
     558        verify( TL_GET( preemption_state ).enabled );
    557559}
    558560
    … …  
    560562        __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
    561563
    562         verify( preemption_state.enabled );
     564        verify( TL_GET( preemption_state ).enabled );
    563565        disable_interrupts();
    564         verify( !preemption_state.enabled );
     566        verify( ! TL_GET( preemption_state ).enabled );
    565567
    566568        // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.
    … …  
    602604
    603605        // first task to abort ?
    604         if ( !kernel_abort_called ) {                   // not first task to abort ?
     606        if ( ! kernel_abort_called ) {                  // not first task to abort ?
    605607                kernel_abort_called = true;
    606608                unlock( kernel_abort_lock );
    … …  
    617619        }
    618620
    619         return this_thread;
     621        return TL_GET( this_thread );
    620622}
    621623
    … …  
    626628        __cfaabi_dbg_bits_write( abort_text, len );
    627629
    628         if ( thrd != this_coroutine ) {
    629                 len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
     630        if ( get_coroutine(thrd) != TL_GET( this_coroutine ) ) {
     631                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", TL_GET( this_coroutine )->name, TL_GET( this_coroutine ) );
    630632                __cfaabi_dbg_bits_write( abort_text, len );
    631633        }
    … …  
    636638
    637639int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
    638         return get_coroutine(this_thread) == get_coroutine(mainThread) ? 4 : 2;
     640        return get_coroutine(TL_GET( this_thread )) == get_coroutine(mainThread) ? 4 : 2;
    639641}
    640642
    … …  
    666668        if ( count < 0 ) {
    667669                // queue current task
    668                 append( waiting, (thread_desc *)this_thread );
     670                append( waiting, (thread_desc *)TL_GET( this_thread ) );
    669671
    670672                // atomically release spin lock and block

  • src/libcfa/concurrency/kernel_private.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon Feb 13 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:58:09 2017
    13 // Update Count     : 2
     12// Last Modified On : Thu Mar 29 14:06:40 2018
     13// Update Count     : 3
    1414//
    1515
    … …  
    6666extern event_kernel_t * event_kernel;
    6767
    68 extern thread_local coroutine_desc * volatile this_coroutine;
    69 extern thread_local thread_desc *    volatile this_thread;
    70 extern thread_local processor *      volatile this_processor;
     68//extern thread_local coroutine_desc * volatile this_coroutine;
     69//extern thread_local thread_desc *    volatile this_thread;
     70//extern thread_local processor *      volatile this_processor;
    7171
    7272// extern volatile thread_local bool preemption_in_progress;

  • src/libcfa/concurrency/monitor.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Thd Feb 23 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb 16 14:49:53 2018
    13 // Update Count     : 5
     12// Last Modified On : Fri Mar 30 14:30:26 2018
     13// Update Count     : 9
    1414//
    1515
    … …  
    8585                // Lock the monitor spinlock
    8686                lock( this->lock __cfaabi_dbg_ctx2 );
    87                 thread_desc * thrd = this_thread;
     87                thread_desc * thrd = TL_GET( this_thread );
    8888
    8989                __cfaabi_dbg_print_safe( "Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
    … …  
    134134                // Lock the monitor spinlock
    135135                lock( this->lock __cfaabi_dbg_ctx2 );
    136                 thread_desc * thrd = this_thread;
     136                thread_desc * thrd = TL_GET( this_thread );
    137137
    138138                __cfaabi_dbg_print_safe( "Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
    … …  
    168168
    169169                        // Create the node specific to this wait operation
    170                         wait_ctx_primed( this_thread, 0 )
     170                        wait_ctx_primed( TL_GET( this_thread ), 0 )
    171171
    172172                        // Some one else has the monitor, wait for him to finish and then run
    … …  
    179179                        __cfaabi_dbg_print_safe( "Kernel :  blocking \n" );
    180180
    181                         wait_ctx( this_thread, 0 )
     181                        wait_ctx( TL_GET( this_thread ), 0 )
    182182                        this->dtor_node = &waiter;
    183183
    … …  
    199199                lock( this->lock __cfaabi_dbg_ctx2 );
    200200
    201                 __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
    202 
    203                 verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
     201                __cfaabi_dbg_print_safe( "Kernel : %10p Leaving mon %p (%p)\n", TL_GET( this_thread ), this, this->owner);
     202
     203                verifyf( TL_GET( this_thread ) == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", TL_GET( this_thread ), this->owner, this->recursion, this );
    204204
    205205                // Leaving a recursion level, decrement the counter
    … …  
    227227        void __leave_dtor_monitor_desc( monitor_desc * this ) {
    228228                __cfaabi_dbg_debug_do(
    229                         if( this_thread != this->owner ) {
    230                                 abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
     229                        if( TL_GET( this_thread ) != this->owner ) {
     230                                abort( "Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, TL_GET( this_thread ), this->owner);
    231231                        }
    232232                        if( this->recursion != 1 ) {
    … …  
    297297
    298298        // Save previous thread context
    299         this.prev = this_thread->monitors;
     299        this.prev = TL_GET( this_thread )->monitors;
    300300
    301301        // Update thread context (needed for conditions)
    302         (this_thread->monitors){m, count, func};
     302        (TL_GET( this_thread )->monitors){m, count, func};
    303303
    304304        // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
    … …  
    322322
    323323        // Restore thread context
    324         this_thread->monitors = this.prev;
     324        TL_GET( this_thread )->monitors = this.prev;
    325325}
    326326
    … …  
    332332
    333333        // Save previous thread context
    334         this.prev = this_thread->monitors;
     334        this.prev = TL_GET( this_thread )->monitors;
    335335
    336336        // Update thread context (needed for conditions)
    337         (this_thread->monitors){m, 1, func};
     337        (TL_GET( this_thread )->monitors){m, 1, func};
    338338
    339339        __enter_monitor_dtor( this.m, func );
    … …  
    346346
    347347        // Restore thread context
    348         this_thread->monitors = this.prev;
     348        TL_GET( this_thread )->monitors = this.prev;
    349349}
    350350
    … …  
    386386
    387387        // Create the node specific to this wait operation
    388         wait_ctx( this_thread, user_info );
     388        wait_ctx( TL_GET( this_thread ), user_info );
    389389
    390390        // Append the current wait operation to the ones already queued on the condition
    … …  
    425425        //Some more checking in debug
    426426        __cfaabi_dbg_debug_do(
    427                 thread_desc * this_thrd = this_thread;
     427                thread_desc * this_thrd = TL_GET( this_thread );
    428428                if ( this.monitor_count != this_thrd->monitors.size ) {
    429429                        abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size );
    … …  
    473473
    474474        // Create the node specific to this wait operation
    475         wait_ctx_primed( this_thread, 0 )
     475        wait_ctx_primed( TL_GET( this_thread ), 0 )
    476476
    477477        //save contexts
    … …  
    566566
    567567                                // Create the node specific to this wait operation
    568                                 wait_ctx_primed( this_thread, 0 );
     568                                wait_ctx_primed( TL_GET( this_thread ), 0 );
    569569
    570570                                // Save monitor states
    … …  
    612612
    613613        // Create the node specific to this wait operation
    614         wait_ctx_primed( this_thread, 0 );
     614        wait_ctx_primed( TL_GET( this_thread ), 0 );
    615615
    616616        monitor_save;
    … …  
    618618
    619619        for( __lock_size_t i = 0; i < count; i++) {
    620                 verify( monitors[i]->owner == this_thread );
     620                verify( monitors[i]->owner == TL_GET( this_thread ) );
    621621        }
    622622
    … …  
    812812
    813813static inline void brand_condition( condition & this ) {
    814         thread_desc * thrd = this_thread;
     814        thread_desc * thrd = TL_GET( this_thread );
    815815        if( !this.monitors ) {
    816816                // __cfaabi_dbg_print_safe( "Branding\n" );

  • src/libcfa/concurrency/preemption.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon Jun 5 14:20:42 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Feb  9 16:38:13 2018
    13 // Update Count     : 14
     12// Last Modified On : Mon Apr  9 13:52:39 2018
     13// Update Count     : 36
    1414//
    1515
    … …  
    2323}
    2424
    25 #include "bits/cfatime.h"
    2625#include "bits/signal.h"
    2726
    2827#if !defined(__CFA_DEFAULT_PREEMPTION__)
    29 #define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
     28#define __CFA_DEFAULT_PREEMPTION__ 10`ms
    3029#endif
    3130
    32 __cfa_time_t default_preemption() __attribute__((weak)) {
     31Duration default_preemption() __attribute__((weak)) {
    3332        return __CFA_DEFAULT_PREEMPTION__;
    3433}
    … …  
    7877
    7978// Get next expired node
    80 static inline alarm_node_t * get_expired( alarm_list_t * alarms, __cfa_time_t currtime ) {
     79static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
    8180        if( !alarms->head ) return NULL;                          // If no alarms return null
    8281        if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
    … …  
    8887        alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
    8988        alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
    90         __cfa_time_t currtime = __kernel_get_time();    // Check current time once so we everything "happens at once"
     89        Time currtime = __kernel_get_time();                    // Check current time once so we everything "happens at once"
    9190
    9291        //Loop throught every thing expired
    … …  
    102101
    103102                // Check if this is a periodic alarm
    104                 __cfa_time_t period = node->period;
     103                Duration period = node->period;
    105104                if( period > 0 ) {
    106105                        node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
    … …  
    117116
    118117// Update the preemption of a processor and notify interested parties
    119 void update_preemption( processor * this, __cfa_time_t duration ) {
     118void update_preemption( processor * this, Duration duration ) {
    120119        alarm_node_t * alarm = this->preemption_alarm;
    121120
    122121        // Alarms need to be enabled
    123         if ( duration > 0 && !alarm->set ) {
     122        if ( duration > 0 && ! alarm->set ) {
    124123                alarm->alarm = __kernel_get_time() + duration;
    125124                alarm->period = duration;
    126125                register_self( alarm );
    127126        }
    128         // Zero duraction but alarm is set
     127        // Zero duration but alarm is set
    129128        else if ( duration == 0 && alarm->set ) {
    130129                unregister_self( alarm );
    … …  
    150149        // Disable interrupts by incrementing the counter
    151150        void disable_interrupts() {
    152                 preemption_state.enabled = false;
    153                 __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
    154                 preemption_state.disable_count = new_val;
     151                TL_GET( preemption_state ).enabled = false;
     152                __attribute__((unused)) unsigned short new_val = TL_GET( preemption_state ).disable_count + 1;
     153                TL_GET( preemption_state ).disable_count = new_val;
    155154                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
    156155        }
    … …  
    159158        // If counter reaches 0, execute any pending CtxSwitch
    160159        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
    161                 processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
    162                 thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
    163 
    164                 unsigned short prev = preemption_state.disable_count;
    165                 preemption_state.disable_count -= 1;
     160                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
     161                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
     162
     163                unsigned short prev = TL_GET( preemption_state ).disable_count;
     164                TL_GET( preemption_state ).disable_count -= 1;
    166165                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
    167166
    168167                // Check if we need to prempt the thread because an interrupt was missed
    169168                if( prev == 1 ) {
    170                         preemption_state.enabled = true;
     169                        TL_GET( preemption_state ).enabled = true;
    171170                        if( proc->pending_preemption ) {
    172171                                proc->pending_preemption = false;
    … …  
    182181        // Don't execute any pending CtxSwitch even if counter reaches 0
    183182        void enable_interrupts_noPoll() {
    184                 unsigned short prev = preemption_state.disable_count;
    185                 preemption_state.disable_count -= 1;
     183                unsigned short prev = TL_GET( preemption_state ).disable_count;
     184                TL_GET( preemption_state ).disable_count -= 1;
    186185                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
    187186                if( prev == 1 ) {
    188                         preemption_state.enabled = true;
     187                        TL_GET( preemption_state ).enabled = true;
    189188                }
    190189        }
    … …  
    236235// If false : preemption is unsafe and marked as pending
    237236static inline bool preemption_ready() {
    238         bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
    239         this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
     237        bool ready = TL_GET( preemption_state ).enabled && !TL_GET( preemption_state ).in_progress; // Check if preemption is safe
     238        TL_GET( this_processor )->pending_preemption = !ready;                  // Adjust the pending flag accordingly
    240239        return ready;
    241240}
    … …  
    251250
    252251        // Start with preemption disabled until ready
    253         preemption_state.enabled = false;
    254         preemption_state.disable_count = 1;
     252        TL_GET( preemption_state ).enabled = false;
     253        TL_GET( preemption_state ).disable_count = 1;
    255254
    256255        // Initialize the event kernel
    … …  
    291290// Used by thread to control when they want to receive preemption signals
    292291void ?{}( preemption_scope & this, processor * proc ) {
    293         (this.alarm){ proc, 0`cfa_s, 0`cfa_s };
     292        (this.alarm){ proc, (Time){ 0 }, 0`s };
    294293        this.proc = proc;
    295294        this.proc->preemption_alarm = &this.alarm;
    … …  
    301300        disable_interrupts();
    302301
    303         update_preemption( this.proc, 0`cfa_s );
     302        update_preemption( this.proc, 0`s );
    304303}
    305304
    … …  
    317316        // before the kernel thread has even started running. When that happens an iterrupt
    318317        // we a null 'this_processor' will be caught, just ignore it.
    319         if(!this_processor) return;
     318        if(!TL_GET( this_processor )) return;
    320319
    321320        choose(sfp->si_value.sival_int) {
    322321                case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
    323                 case PREEMPT_TERMINATE: verify(this_processor->do_terminate);
     322                case PREEMPT_TERMINATE: verify(TL_GET( this_processor )->do_terminate);
    324323                default:
    325324                        abort( "internal error, signal value is %d", sfp->si_value.sival_int );
    … …  
    331330        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
    332331
    333         preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
     332        TL_GET( preemption_state ).in_progress = true;  // Sync flag : prevent recursive calls to the signal handler
    334333        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
    335         preemption_state.in_progress = false;                    // Clear the in progress flag
     334        TL_GET( preemption_state ).in_progress = false; // Clear the in progress flag
    336335
    337336        // Preemption can occur here
    338337
    339         BlockInternal( (thread_desc*)this_thread );        // Do the actual CtxSwitch
     338        BlockInternal( (thread_desc*)TL_GET( this_thread ) ); // Do the actual CtxSwitch
    340339}
    341340

  • src/libcfa/concurrency/preemption.h

    rb2fe1c9 r32cab5b  
    1010// Created On       : Mon Jun 5 14:20:42 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 21 22:34:25 2017
    13 // Update Count     : 1
     12// Last Modified On : Fri Mar 23 17:18:53 2018
     13// Update Count     : 2
    1414//
    1515
    … …  
    2121void kernel_start_preemption();
    2222void kernel_stop_preemption();
    23 void update_preemption( processor * this, __cfa_time_t duration );
     23void update_preemption( processor * this, Duration duration );
    2424void tick_preemption();
    2525

  • src/libcfa/concurrency/thread

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:59:40 2017
    13 // Update Count     : 3
     12// Last Modified On : Thu Mar 29 14:07:11 2018
     13// Update Count     : 4
    1414//
    1515
    … …  
    5252}
    5353
    54 extern thread_local thread_desc * volatile this_thread;
     54//extern thread_local thread_desc * volatile this_thread;
    5555
    5656forall( dtype T | is_thread(T) )

  • src/libcfa/concurrency/thread.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Jan 17 12:27:26 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jul 21 22:34:46 2017
    13 // Update Count     : 1
     12// Last Modified On : Fri Mar 30 17:19:52 2018
     13// Update Count     : 8
    1414//
    1515
    … …  
    2626}
    2727
    28 extern volatile thread_local processor * this_processor;
     28//extern volatile thread_local processor * this_processor;
    2929
    3030//-----------------------------------------------------------------------------
    … …  
    7575        coroutine_desc* thrd_c = get_coroutine(this);
    7676        thread_desc   * thrd_h = get_thread   (this);
    77         thrd_c->last = this_coroutine;
     77        thrd_c->last = TL_GET( this_coroutine );
    7878
    7979        // __cfaabi_dbg_print_safe("Thread start : %p (t %p, c %p)\n", this, thrd_c, thrd_h);
    … …  
    8181        disable_interrupts();
    8282        create_stack(&thrd_c->stack, thrd_c->stack.size);
    83         this_coroutine = thrd_c;
     83        TL_SET( this_coroutine, thrd_c );
    8484        CtxStart(&this, CtxInvokeThread);
    8585        assert( thrd_c->last->stack.context );
    … …  
    9292extern "C" {
    9393        void __finish_creation(void) {
    94                 coroutine_desc* thrd_c = this_coroutine;
     94                coroutine_desc* thrd_c = TL_GET( this_coroutine );
    9595                ThreadCtxSwitch( thrd_c, thrd_c->last );
    9696        }
    … …  
    9898
    9999void yield( void ) {
    100         verify( preemption_state.enabled );
    101         BlockInternal( this_thread );
    102         verify( preemption_state.enabled );
     100        verify( TL_GET( preemption_state ).enabled );
     101        BlockInternal( TL_GET( this_thread ) );
     102        verify( TL_GET( preemption_state ).enabled );
    103103}
    104104
    … …  
    116116        // set new coroutine that the processor is executing
    117117        // and context switch to it
    118         this_coroutine = dst;
     118        TL_SET( this_coroutine, dst );
    119119        assert( src->stack.context );
    120120        CtxSwitch( src->stack.context, dst->stack.context );
    121         this_coroutine = src;
     121        TL_SET( this_coroutine, src );
    122122
    123123        // set state of new coroutine to active

  • src/libcfa/iostream

    rb2fe1c9 r32cab5b  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jan 25 13:08:39 2018
    13 // Update Count     : 149
     12// Last Modified On : Thu Apr 12 14:34:37 2018
     13// Update Count     : 150
    1414//
    1515
    … …  
    159159forall( dtype istype | istream( istype ) ) istype & ?|?( istype &, _Istream_cstrC );
    160160
     161
     162#include <time_t.h>                                                                             // Duration (constructors) / Time (constructors)
     163
     164forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
     165forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
     166
     167
    161168// Local Variables: //
    162169// mode: c //

  • src/libcfa/stdlib.c

    rb2fe1c9 r32cab5b  
    9999        char * eeptr;
    100100        re = strtof( sptr, &eeptr );
    101         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     101        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
    102102        im = strtof( eeptr, &eeptr );
    103         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     103        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
    104104        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
    105105        return re + im * _Complex_I;
    … …  
    110110        char * eeptr;
    111111        re = strtod( sptr, &eeptr );
    112         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     112        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
    113113        im = strtod( eeptr, &eeptr );
    114         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     114        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
    115115        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
    116116        return re + im * _Complex_I;
    … …  
    121121        char * eeptr;
    122122        re = strtold( sptr, &eeptr );
    123         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     123        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    124124        im = strtold( eeptr, &eeptr );
    125         if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     125        if ( sptr == eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    126126        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    127127        return re + im * _Complex_I;

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

    rb2fe1c9 r32cab5b  
    33    L: __attribute__ ((unused)) ((void)1);
    44}
    5 __attribute__ ((unused)) struct __anonymous0 {
     5struct __attribute__ ((unused)) __anonymous0 {
    66};
    77static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    … …  
    2020    return ___ret__13s__anonymous0_1;
    2121}
    22 __attribute__ ((unused)) struct Agn1;
    23 __attribute__ ((unused)) struct Agn2 {
     22struct __attribute__ ((unused)) Agn1;
     23struct __attribute__ ((unused)) Agn2 {
    2424};
    2525static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
    … …  
    4545    __E2__C5eAgn3_1,
    4646};
    47 __attribute__ ((unused)) struct __anonymous2;
    48 __attribute__ ((unused)) struct __anonymous3;
     47struct __attribute__ ((unused)) __anonymous2;
     48struct __attribute__ ((unused)) __anonymous3;
    4949struct Fdl {
    5050    __attribute__ ((unused)) signed int __f1__i_1;
    … …  
    314314    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
    315315    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    316     __attribute__ ((unused)) struct __anonymous4 {
     316    struct __attribute__ ((unused)) __anonymous4 {
    317317        signed int __i__i_2;
    318318    };

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

    rb2fe1c9 r32cab5b  
    33    L: __attribute__ ((unused)) ((void)1);
    44}
    5 __attribute__ ((unused)) struct __anonymous0 {
     5struct __attribute__ ((unused)) __anonymous0 {
    66};
    77static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
    … …  
    2020    return ___ret__13s__anonymous0_1;
    2121}
    22 __attribute__ ((unused)) struct Agn1;
    23 __attribute__ ((unused)) struct Agn2 {
     22struct __attribute__ ((unused)) Agn1;
     23struct __attribute__ ((unused)) Agn2 {
    2424};
    2525static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
    … …  
    4545    __E2__C5eAgn3_1,
    4646};
    47 __attribute__ ((unused)) struct __anonymous2;
    48 __attribute__ ((unused)) struct __anonymous3;
     47struct __attribute__ ((unused)) __anonymous2;
     48struct __attribute__ ((unused)) __anonymous3;
    4949struct Fdl {
    5050    __attribute__ ((unused)) signed int __f1__i_1;
    … …  
    314314    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[10]));
    315315    ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
    316     __attribute__ ((unused)) struct __anonymous4 {
     316    struct __attribute__ ((unused)) __anonymous4 {
    317317        signed int __i__i_2;
    318318    };

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

    rb2fe1c9 r32cab5b  
    122122struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1340, signed int __size__i_1);
    123123void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1341), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1342), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1343, char *__anonymous_object1344, unsigned long int __anonymous_object1345), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1346, char __anonymous_object1347), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1348, const char *__fmt__PCc_1, ...), void *__anonymous_object1349, struct _Istream_cstrC __anonymous_object1350);
     124struct Duration {
     125    signed long int __tv__l_1;
     126};
     127static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
     128static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
     129static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
     130static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
     131static inline void ___constructor__F_R9sDurationl_autogen___1(struct Duration *___dst__R9sDuration_1, signed long int __tv__l_1);
     132static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     133    ((void)((*___dst__R9sDuration_1).__tv__l_1) /* ?{} */);
     134}
     135static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
     136    ((void)((*___dst__R9sDuration_1).__tv__l_1=___src__9sDuration_1.__tv__l_1) /* ?{} */);
     137}
     138static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     139    ((void)((*___dst__R9sDuration_1).__tv__l_1) /* ^?{} */);
     140}
     141static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
     142    struct Duration ___ret__9sDuration_1;
     143    ((void)((*___dst__R9sDuration_1).__tv__l_1=___src__9sDuration_1.__tv__l_1));
     144    ((void)___constructor__F_R9sDuration9sDuration_autogen___1((&___ret__9sDuration_1), (*___dst__R9sDuration_1)));
     145    return ___ret__9sDuration_1;
     146}
     147static inline void ___constructor__F_R9sDurationl_autogen___1(struct Duration *___dst__R9sDuration_1, signed long int __tv__l_1){
     148    ((void)((*___dst__R9sDuration_1).__tv__l_1=__tv__l_1) /* ?{} */);
     149}
     150static inline void ___constructor__F_R9sDuration__1(struct Duration *__dur__R9sDuration_1){
     151    ((void)((*__dur__R9sDuration_1).__tv__l_1) /* ?{} */);
     152    ((void)((*__dur__R9sDuration_1).__tv__l_1=((signed long int )0)));
     153}
     154static inline void ___constructor__F_R9sDurationZ__1(struct Duration *__dur__R9sDuration_1, long int __anonymous_object1351){
     155    ((void)((*__dur__R9sDuration_1).__tv__l_1) /* ?{} */);
     156    ((void)((*__dur__R9sDuration_1).__tv__l_1=((signed long int )0)));
     157}
     158struct Time {
     159    unsigned long int __tv__Ul_1;
     160};
     161static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
     162static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
     163static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
     164static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
     165static inline void ___constructor__F_R5sTimeUl_autogen___1(struct Time *___dst__R5sTime_1, unsigned long int __tv__Ul_1);
     166static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     167    ((void)((*___dst__R5sTime_1).__tv__Ul_1) /* ?{} */);
     168}
     169static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
     170    ((void)((*___dst__R5sTime_1).__tv__Ul_1=___src__5sTime_1.__tv__Ul_1) /* ?{} */);
     171}
     172static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     173    ((void)((*___dst__R5sTime_1).__tv__Ul_1) /* ^?{} */);
     174}
     175static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
     176    struct Time ___ret__5sTime_1;
     177    ((void)((*___dst__R5sTime_1).__tv__Ul_1=___src__5sTime_1.__tv__Ul_1));
     178    ((void)___constructor__F_R5sTime5sTime_autogen___1((&___ret__5sTime_1), (*___dst__R5sTime_1)));
     179    return ___ret__5sTime_1;
     180}
     181static inline void ___constructor__F_R5sTimeUl_autogen___1(struct Time *___dst__R5sTime_1, unsigned long int __tv__Ul_1){
     182    ((void)((*___dst__R5sTime_1).__tv__Ul_1=__tv__Ul_1) /* ?{} */);
     183}
     184static inline void ___constructor__F_R5sTime__1(struct Time *__time__R5sTime_1){
     185    ((void)((*__time__R5sTime_1).__tv__Ul_1) /* ?{} */);
     186    ((void)((*__time__R5sTime_1).__tv__Ul_1=((unsigned long int )0)));
     187}
     188static inline void ___constructor__F_R5sTimeZ__1(struct Time *__time__R5sTime_1, long int __anonymous_object1352){
     189    ((void)((*__time__R5sTime_1).__tv__Ul_1) /* ?{} */);
     190    ((void)((*__time__R5sTime_1).__tv__Ul_1=((unsigned long int )0)));
     191}
     192void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd09sDuration__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1353), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1354), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1355, _Bool __anonymous_object1356), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1357), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1358, const char *__anonymous_object1359), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1360), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1361, _Bool __anonymous_object1362), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1363), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1364), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1365), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1366), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1367), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1368, const char *__anonymous_object1369), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1370), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1371, const char *__anonymous_object1372), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1373), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1374), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1375, const char *__anonymous_object1376, unsigned long int __anonymous_object1377), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1378, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Duration __dur__9sDuration_1);
     193void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd05sTime__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1379), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1380), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1381, _Bool __anonymous_object1382), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1383), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1384, const char *__anonymous_object1385), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1386), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1387, _Bool __anonymous_object1388), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1389), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1390), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1391), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1392), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1393), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1394, const char *__anonymous_object1395), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1396), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1397, const char *__anonymous_object1398), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1399), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1400), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1401, const char *__anonymous_object1402, unsigned long int __anonymous_object1403), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1404, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Time __time__5sTime_1);
    124194enum __anonymous0 {
    125195    __sepSize__C13e__anonymous0_1 = 16,
    … …  
    401471
    402472}
    403 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1351);
    404 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1352);
    405 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1353, _Bool __anonymous_object1354);
    406 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1355);
    407 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1356, const char *__anonymous_object1357);
    408 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1358);
    409 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1359, _Bool __anonymous_object1360);
    410 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1361);
    411 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1362);
    412 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1363);
    413 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1364);
    414 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1365);
    415 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1366, const char *__anonymous_object1367);
    416 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1368);
    417 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1369, const char *__anonymous_object1370);
    418 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1371);
    419 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1372);
    420 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1373, const char *__name__PCc_1, const char *__mode__PCc_1);
    421 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1374, const char *__name__PCc_1);
    422 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1375);
    423 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1376, const char *__data__PCc_1, unsigned long int __size__Ul_1);
    424 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1377, const char *__fmt__PCc_1, ...);
     473_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1405);
     474void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1406);
     475void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1407, _Bool __anonymous_object1408);
     476const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1409);
     477void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1410, const char *__anonymous_object1411);
     478_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1412);
     479void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1413, _Bool __anonymous_object1414);
     480void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1415);
     481void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1416);
     482_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1417);
     483_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1418);
     484const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1419);
     485void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1420, const char *__anonymous_object1421);
     486const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1422);
     487void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1423, const char *__anonymous_object1424);
     488signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1425);
     489signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1426);
     490void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1427, const char *__name__PCc_1, const char *__mode__PCc_1);
     491void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1428, const char *__name__PCc_1);
     492void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1429);
     493struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1430, const char *__data__PCc_1, unsigned long int __size__Ul_1);
     494signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1431, const char *__fmt__PCc_1, ...);
    425495void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1);
    426496void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    … …  
    461531struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
    462532struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1);
    463 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1378, const char *__fmt__PCc_1, ...);
     533signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1432, const char *__fmt__PCc_1, ...);
    464534void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
    465535void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    … …  
    471541    struct ofstream *_tmp_cp_ret4;
    472542    __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
    473         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1379))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1380))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1381, _Bool __anonymous_object1382))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1383))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1384, const char *__anonymous_object1385))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1386))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1387, _Bool __anonymous_object1388))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1389))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1390))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1391))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1392))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1393))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1396))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1397, const char *__anonymous_object1398))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1399))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1400))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1401, const char *__anonymous_object1402, unsigned long int __anonymous_object1403))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1404, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    474     }
    475     ((void)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1405))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1406))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1407, _Bool __anonymous_object1408))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1409))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1410, const char *__anonymous_object1411))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1412))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1413, _Bool __anonymous_object1414))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1415))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1416))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1417))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1418))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1419))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1422))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1423, const char *__anonymous_object1424))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1425))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1426))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1427, const char *__anonymous_object1428, unsigned long int __anonymous_object1429))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1430, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1431))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1432))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1433, _Bool __anonymous_object1434))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1435))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1436, const char *__anonymous_object1437))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1438))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1439, _Bool __anonymous_object1440))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1441))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1442))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1443))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1444))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1445))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1448))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1449, const char *__anonymous_object1450))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1451))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1452))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1453, const char *__anonymous_object1454, unsigned long int __anonymous_object1455))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1456, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1457))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1458))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1459, _Bool __anonymous_object1460))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1461))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1462, const char *__anonymous_object1463))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1464))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1465, _Bool __anonymous_object1466))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1467))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1468))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1469))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1470))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1471))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1474))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1475, const char *__anonymous_object1476))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1477))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1478))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1479, const char *__anonymous_object1480, unsigned long int __anonymous_object1481))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1482, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret2)), __v__c_1)))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1483))(&_thunk0)))))) , _tmp_cp_ret4));
     543        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1433))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1434))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1437))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1438, const char *__anonymous_object1439))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1440))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1441, _Bool __anonymous_object1442))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1443))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1444))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1445))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1446))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1447))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1448, const char *__anonymous_object1449))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1450))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1451, const char *__anonymous_object1452))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1453))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1454))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1455, const char *__anonymous_object1456, unsigned long int __anonymous_object1457))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1458, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     544    }
     545    ((void)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1459))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1460))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1463))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1464, const char *__anonymous_object1465))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1466))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1467, _Bool __anonymous_object1468))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1469))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1470))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1471))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1472))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1473))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1474, const char *__anonymous_object1475))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1476))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1477, const char *__anonymous_object1478))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1479))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1480))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1481, const char *__anonymous_object1482, unsigned long int __anonymous_object1483))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1484, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1485))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1486))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1489))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1490, const char *__anonymous_object1491))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1492))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1493, _Bool __anonymous_object1494))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1495))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1496))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1497))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1498))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1499))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1500, const char *__anonymous_object1501))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1502))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1503, const char *__anonymous_object1504))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1505))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1506))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1507, const char *__anonymous_object1508, unsigned long int __anonymous_object1509))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1510, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1511))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1512))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1515))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1516, const char *__anonymous_object1517))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1518))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1519, _Bool __anonymous_object1520))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1521))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1522))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1523))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1524))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1525))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1526, const char *__anonymous_object1527))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1528))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1529, const char *__anonymous_object1530))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1531))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1532))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1533, const char *__anonymous_object1534, unsigned long int __anonymous_object1535))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1536, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret2)), __v__c_1)))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1537))(&_thunk0)))))) , _tmp_cp_ret4));
    476546}
    477547void __f__F_Sc__1(signed char __v__Sc_1){
    … …  
    480550    struct ofstream *_tmp_cp_ret7;
    481551    __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
    482         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1484))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1485))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1486, _Bool __anonymous_object1487))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1488))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1489, const char *__anonymous_object1490))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1491))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1492, _Bool __anonymous_object1493))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1494))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1495))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1496))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1497))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1498))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1501))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1502, const char *__anonymous_object1503))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1504))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1505))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1506, const char *__anonymous_object1507, unsigned long int __anonymous_object1508))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1509, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    483     }
    484     ((void)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1510))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1511))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1512, _Bool __anonymous_object1513))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1514))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1515, const char *__anonymous_object1516))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1517))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1518, _Bool __anonymous_object1519))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1520))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1521))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1522))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1523))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1524))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1527))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1528, const char *__anonymous_object1529))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1530))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1531))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1532, const char *__anonymous_object1533, unsigned long int __anonymous_object1534))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1535, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1536))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1537))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1538, _Bool __anonymous_object1539))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1540))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1541, const char *__anonymous_object1542))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1543))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1544, _Bool __anonymous_object1545))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1546))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1547))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1548))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1549))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1550))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1553))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1554, const char *__anonymous_object1555))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1556))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1557))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1558, const char *__anonymous_object1559, unsigned long int __anonymous_object1560))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1561, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1562))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1563))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1564, _Bool __anonymous_object1565))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1566))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1567, const char *__anonymous_object1568))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1569))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1570, _Bool __anonymous_object1571))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1572))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1573))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1574))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1575))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1576))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1579))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1580, const char *__anonymous_object1581))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1582))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1583))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1584, const char *__anonymous_object1585, unsigned long int __anonymous_object1586))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1587, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret5)), __v__Sc_1)))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1588))(&_thunk1)))))) , _tmp_cp_ret7));
     552        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1538))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1539))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1542))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1543, const char *__anonymous_object1544))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1545))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1546, _Bool __anonymous_object1547))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1548))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1549))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1550))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1551))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1552))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1553, const char *__anonymous_object1554))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1555))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1556, const char *__anonymous_object1557))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1558))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1559))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1560, const char *__anonymous_object1561, unsigned long int __anonymous_object1562))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1563, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     553    }
     554    ((void)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1564))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1565))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1568))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1569, const char *__anonymous_object1570))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1571))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1572, _Bool __anonymous_object1573))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1574))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1575))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1576))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1577))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1578))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1579, const char *__anonymous_object1580))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1581))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1582, const char *__anonymous_object1583))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1584))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1585))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1586, const char *__anonymous_object1587, unsigned long int __anonymous_object1588))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1589, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1590))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1591))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1594))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1595, const char *__anonymous_object1596))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1597))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1598, _Bool __anonymous_object1599))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1600))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1601))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1602))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1603))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1604))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1605, const char *__anonymous_object1606))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1607))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1608, const char *__anonymous_object1609))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1610))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1611))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1612, const char *__anonymous_object1613, unsigned long int __anonymous_object1614))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1615, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1616))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1617))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1620))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1621, const char *__anonymous_object1622))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1623))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1624, _Bool __anonymous_object1625))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1626))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1627))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1628))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1629))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1630))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1631, const char *__anonymous_object1632))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1633))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1634, const char *__anonymous_object1635))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1636))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1637))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1638, const char *__anonymous_object1639, unsigned long int __anonymous_object1640))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1641, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret5)), __v__Sc_1)))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1642))(&_thunk1)))))) , _tmp_cp_ret7));
    485555}
    486556void __f__F_Uc__1(unsigned char __v__Uc_1){
    … …  
    489559    struct ofstream *_tmp_cp_ret10;
    490560    __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
    491         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1589))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1590))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1591, _Bool __anonymous_object1592))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1593))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1594, const char *__anonymous_object1595))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1596))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1597, _Bool __anonymous_object1598))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1599))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1600))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1601))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1602))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1603))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1606))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1607, const char *__anonymous_object1608))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1609))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1610))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1611, const char *__anonymous_object1612, unsigned long int __anonymous_object1613))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1614, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    492     }
    493     ((void)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1615))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1616))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1617, _Bool __anonymous_object1618))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1619))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1620, const char *__anonymous_object1621))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1622))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1623, _Bool __anonymous_object1624))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1625))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1626))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1627))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1628))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1629))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1632))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1633, const char *__anonymous_object1634))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1635))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1636))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1637, const char *__anonymous_object1638, unsigned long int __anonymous_object1639))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1640, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1641))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1642))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1643, _Bool __anonymous_object1644))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1645))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1646, const char *__anonymous_object1647))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1648))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1649, _Bool __anonymous_object1650))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1651))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1652))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1653))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1654))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1655))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1658))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1659, const char *__anonymous_object1660))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1661))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1662))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1663, const char *__anonymous_object1664, unsigned long int __anonymous_object1665))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1666, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1667))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1668))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1669, _Bool __anonymous_object1670))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1671))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1672, const char *__anonymous_object1673))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1674))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1675, _Bool __anonymous_object1676))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1677))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1678))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1679))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1680))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1681))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1684))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1685, const char *__anonymous_object1686))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1687))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1688))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1689, const char *__anonymous_object1690, unsigned long int __anonymous_object1691))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1692, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret8)), __v__Uc_1)))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1693))(&_thunk2)))))) , _tmp_cp_ret10));
     561        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1643))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1644))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1647))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1648, const char *__anonymous_object1649))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1650))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1651, _Bool __anonymous_object1652))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1653))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1654))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1655))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1656))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1657))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1658, const char *__anonymous_object1659))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1660))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1661, const char *__anonymous_object1662))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1663))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1664))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1665, const char *__anonymous_object1666, unsigned long int __anonymous_object1667))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1668, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     562    }
     563    ((void)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1669))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1670))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1673))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1674, const char *__anonymous_object1675))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1676))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1677, _Bool __anonymous_object1678))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1679))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1680))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1681))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1682))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1683))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1684, const char *__anonymous_object1685))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1686))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1687, const char *__anonymous_object1688))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1689))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1690))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1691, const char *__anonymous_object1692, unsigned long int __anonymous_object1693))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1694, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1695))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1696))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1699))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1700, const char *__anonymous_object1701))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1702))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1703, _Bool __anonymous_object1704))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1705))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1706))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1707))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1708))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1709))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1710, const char *__anonymous_object1711))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1712))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1713, const char *__anonymous_object1714))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1715))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1716))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1717, const char *__anonymous_object1718, unsigned long int __anonymous_object1719))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1720, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1721))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1722))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1725))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1726, const char *__anonymous_object1727))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1728))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1729, _Bool __anonymous_object1730))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1731))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1732))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1733))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1734))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1735))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1736, const char *__anonymous_object1737))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1738))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1739, const char *__anonymous_object1740))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1741))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1742))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1743, const char *__anonymous_object1744, unsigned long int __anonymous_object1745))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1746, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret8)), __v__Uc_1)))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1747))(&_thunk2)))))) , _tmp_cp_ret10));
    494564}
    495565void __f__F_s__1(signed short int __v__s_1){
    … …  
    498568    struct ofstream *_tmp_cp_ret13;
    499569    __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
    500         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1694))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1695))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1696, _Bool __anonymous_object1697))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1698))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1699, const char *__anonymous_object1700))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1701))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1702, _Bool __anonymous_object1703))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1704))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1705))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1706))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1707))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1708))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1711))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1712, const char *__anonymous_object1713))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1714))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1715))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1716, const char *__anonymous_object1717, unsigned long int __anonymous_object1718))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1719, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    501     }
    502     ((void)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1720))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1721))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1722, _Bool __anonymous_object1723))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1724))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1725, const char *__anonymous_object1726))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1727))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1728, _Bool __anonymous_object1729))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1730))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1731))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1732))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1733))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1734))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1737))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1738, const char *__anonymous_object1739))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1740))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1741))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1742, const char *__anonymous_object1743, unsigned long int __anonymous_object1744))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1745, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1746))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1747))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1748, _Bool __anonymous_object1749))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1750))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1751, const char *__anonymous_object1752))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1753))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1754, _Bool __anonymous_object1755))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1756))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1757))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1758))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1759))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1760))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1763))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1764, const char *__anonymous_object1765))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1766))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1767))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1768, const char *__anonymous_object1769, unsigned long int __anonymous_object1770))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1771, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1772))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1773))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1774, _Bool __anonymous_object1775))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1776))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1777, const char *__anonymous_object1778))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1779))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1780, _Bool __anonymous_object1781))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1782))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1783))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1784))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1785))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1786))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1789))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1790, const char *__anonymous_object1791))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1792))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1793))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1794, const char *__anonymous_object1795, unsigned long int __anonymous_object1796))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1797, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret11)), __v__s_1)))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1798))(&_thunk3)))))) , _tmp_cp_ret13));
     570        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1748))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1749))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1752))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1753, const char *__anonymous_object1754))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1755))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1756, _Bool __anonymous_object1757))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1758))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1759))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1760))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1761))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1762))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1763, const char *__anonymous_object1764))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1765))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1766, const char *__anonymous_object1767))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1768))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1769))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1770, const char *__anonymous_object1771, unsigned long int __anonymous_object1772))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1773, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     571    }
     572    ((void)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1774))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1775))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1778))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1779, const char *__anonymous_object1780))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1781))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1782, _Bool __anonymous_object1783))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1784))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1785))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1786))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1787))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1788))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1789, const char *__anonymous_object1790))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1791))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1792, const char *__anonymous_object1793))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1794))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1795))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1796, const char *__anonymous_object1797, unsigned long int __anonymous_object1798))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1799, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1800))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1801))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1804))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1805, const char *__anonymous_object1806))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1807))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1808, _Bool __anonymous_object1809))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1810))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1811))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1812))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1813))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1814))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1815, const char *__anonymous_object1816))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1817))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1818, const char *__anonymous_object1819))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1820))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1821))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1822, const char *__anonymous_object1823, unsigned long int __anonymous_object1824))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1825, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1826))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1827))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1830))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1831, const char *__anonymous_object1832))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1833))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1834, _Bool __anonymous_object1835))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1836))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1837))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1838))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1839))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1840))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1841, const char *__anonymous_object1842))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1843))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1844, const char *__anonymous_object1845))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1846))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1847))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1848, const char *__anonymous_object1849, unsigned long int __anonymous_object1850))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1851, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret11)), __v__s_1)))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1852))(&_thunk3)))))) , _tmp_cp_ret13));
    503573}
    504574void __f__F_Us__1(unsigned short int __v__Us_1){
    … …  
    507577    struct ofstream *_tmp_cp_ret16;
    508578    __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
    509         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1799))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1800))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1801, _Bool __anonymous_object1802))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1803))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1804, const char *__anonymous_object1805))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1806))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1807, _Bool __anonymous_object1808))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1809))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1810))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1811))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1812))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1813))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1816))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1817, const char *__anonymous_object1818))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1819))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1820))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1821, const char *__anonymous_object1822, unsigned long int __anonymous_object1823))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1824, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    510     }
    511     ((void)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1825))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1826))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1827, _Bool __anonymous_object1828))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1829))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1830, const char *__anonymous_object1831))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1832))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1833, _Bool __anonymous_object1834))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1835))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1836))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1837))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1838))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1839))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1842))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1843, const char *__anonymous_object1844))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1845))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1846))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1847, const char *__anonymous_object1848, unsigned long int __anonymous_object1849))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1850, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1851))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1852))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1853, _Bool __anonymous_object1854))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1855))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1856, const char *__anonymous_object1857))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1858))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1859, _Bool __anonymous_object1860))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1861))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1862))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1863))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1864))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1865))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1868))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1869, const char *__anonymous_object1870))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1871))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1872))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1873, const char *__anonymous_object1874, unsigned long int __anonymous_object1875))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1876, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1877))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1878))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1879, _Bool __anonymous_object1880))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1881))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1882, const char *__anonymous_object1883))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1884))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1885, _Bool __anonymous_object1886))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1887))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1888))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1889))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1890))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1891))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1894))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1895, const char *__anonymous_object1896))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1897))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1898))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1899, const char *__anonymous_object1900, unsigned long int __anonymous_object1901))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1902, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret14)), __v__Us_1)))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1903))(&_thunk4)))))) , _tmp_cp_ret16));
     579        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1853))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1854))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1857))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1858, const char *__anonymous_object1859))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1860))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1861, _Bool __anonymous_object1862))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1863))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1864))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1865))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1866))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1867))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1868, const char *__anonymous_object1869))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1870))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1871, const char *__anonymous_object1872))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1873))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1874))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1875, const char *__anonymous_object1876, unsigned long int __anonymous_object1877))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1878, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     580    }
     581    ((void)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1879))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1880))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1883))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1884, const char *__anonymous_object1885))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1886))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1887, _Bool __anonymous_object1888))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1889))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1890))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1891))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1892))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1893))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1894, const char *__anonymous_object1895))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1896))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1897, const char *__anonymous_object1898))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1899))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1900))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1901, const char *__anonymous_object1902, unsigned long int __anonymous_object1903))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1904, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1905))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1906))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1909))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1910, const char *__anonymous_object1911))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1912))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1913, _Bool __anonymous_object1914))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1915))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1916))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1917))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1918))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1919))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1920, const char *__anonymous_object1921))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1922))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1923, const char *__anonymous_object1924))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1925))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1926))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1927, const char *__anonymous_object1928, unsigned long int __anonymous_object1929))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1930, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1931))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1932))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1935))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1936, const char *__anonymous_object1937))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1938))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1939, _Bool __anonymous_object1940))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1941))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1942))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1943))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1944))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1945))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1946, const char *__anonymous_object1947))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1948))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1949, const char *__anonymous_object1950))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1951))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1952))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1953, const char *__anonymous_object1954, unsigned long int __anonymous_object1955))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1956, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret14)), __v__Us_1)))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1957))(&_thunk4)))))) , _tmp_cp_ret16));
    512582}
    513583void __f__F_Ul__1(unsigned long int __v__Ul_1){
    … …  
    516586    struct ofstream *_tmp_cp_ret19;
    517587    __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
    518         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1904))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1905))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1906, _Bool __anonymous_object1907))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1908))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1909, const char *__anonymous_object1910))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1911))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1912, _Bool __anonymous_object1913))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1914))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1915))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1916))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1917))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1918))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1921))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1922, const char *__anonymous_object1923))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1924))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1925))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1926, const char *__anonymous_object1927, unsigned long int __anonymous_object1928))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1929, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    519     }
    520     ((void)(((void)(_tmp_cp_ret19=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1930))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1931))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1932, _Bool __anonymous_object1933))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1934))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1935, const char *__anonymous_object1936))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1937))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1938, _Bool __anonymous_object1939))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1940))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1941))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1942))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1943))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1944))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1947))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1948, const char *__anonymous_object1949))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1950))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1951))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1952, const char *__anonymous_object1953, unsigned long int __anonymous_object1954))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1955, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(((_Bool (*)(void *__anonymous_object1956))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1957))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1958, _Bool __anonymous_object1959))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1960))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1961, const char *__anonymous_object1962))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1963))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1964, _Bool __anonymous_object1965))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1966))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1967))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1968))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1969))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1970))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1973))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1974, const char *__anonymous_object1975))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1976))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1977))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1978, const char *__anonymous_object1979, unsigned long int __anonymous_object1980))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1981, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1982))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1983))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1984, _Bool __anonymous_object1985))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1986))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1987, const char *__anonymous_object1988))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1989))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1990, _Bool __anonymous_object1991))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1992))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1993))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1994))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1995))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1996))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1997, const char *__anonymous_object1998))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1999))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2000, const char *__anonymous_object2001))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2002))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2003))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2004, const char *__anonymous_object2005, unsigned long int __anonymous_object2006))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2007, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret17)), __v__Ul_1)))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object2008))(&_thunk5)))))) , _tmp_cp_ret19));
     588        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1958))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1959))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1960, _Bool __anonymous_object1961))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1962))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1963, const char *__anonymous_object1964))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1965))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1966, _Bool __anonymous_object1967))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1968))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1969))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1970))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1971))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1972))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1973, const char *__anonymous_object1974))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1975))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1976, const char *__anonymous_object1977))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1978))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1979))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1980, const char *__anonymous_object1981, unsigned long int __anonymous_object1982))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1983, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     589    }
     590    ((void)(((void)(_tmp_cp_ret19=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1984))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1985))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1986, _Bool __anonymous_object1987))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1988))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1989, const char *__anonymous_object1990))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1991))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1992, _Bool __anonymous_object1993))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1994))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1995))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1996))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1997))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1998))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1999, const char *__anonymous_object2000))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object2001))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2002, const char *__anonymous_object2003))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2004))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2005))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2006, const char *__anonymous_object2007, unsigned long int __anonymous_object2008))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2009, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(((_Bool (*)(void *__anonymous_object2010))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2011))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object2012, _Bool __anonymous_object2013))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object2014))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2015, const char *__anonymous_object2016))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object2017))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2018, _Bool __anonymous_object2019))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object2020))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object2021))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2022))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2023))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object2024))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2025, const char *__anonymous_object2026))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object2027))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2028, const char *__anonymous_object2029))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2030))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2031))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2032, const char *__anonymous_object2033, unsigned long int __anonymous_object2034))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2035, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object2036))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2037))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object2038, _Bool __anonymous_object2039))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object2040))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2041, const char *__anonymous_object2042))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object2043))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2044, _Bool __anonymous_object2045))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object2046))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object2047))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2048))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2049))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object2050))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2051, const char *__anonymous_object2052))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object2053))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2054, const char *__anonymous_object2055))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2056))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2057))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2058, const char *__anonymous_object2059, unsigned long int __anonymous_object2060))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2061, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret17)), __v__Ul_1)))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object2062))(&_thunk5)))))) , _tmp_cp_ret19));
    521591}
    522592signed int __main__Fi___1(){

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

    rb2fe1c9 r32cab5b  
    122122struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1340, signed int __size__i_1);
    123123void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1341), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1342), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1343, char *__anonymous_object1344, unsigned long int __anonymous_object1345), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1346, char __anonymous_object1347), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1348, const char *__fmt__PCc_1, ...), void *__anonymous_object1349, struct _Istream_cstrC __anonymous_object1350);
     124struct Duration {
     125    signed long long int __tv__q_1;
     126};
     127static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
     128static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
     129static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
     130static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
     131static inline void ___constructor__F_R9sDurationq_autogen___1(struct Duration *___dst__R9sDuration_1, signed long long int __tv__q_1);
     132static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     133    ((void)((*___dst__R9sDuration_1).__tv__q_1) /* ?{} */);
     134}
     135static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
     136    ((void)((*___dst__R9sDuration_1).__tv__q_1=___src__9sDuration_1.__tv__q_1) /* ?{} */);
     137}
     138static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     139    ((void)((*___dst__R9sDuration_1).__tv__q_1) /* ^?{} */);
     140}
     141static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
     142    struct Duration ___ret__9sDuration_1;
     143    ((void)((*___dst__R9sDuration_1).__tv__q_1=___src__9sDuration_1.__tv__q_1));
     144    ((void)___constructor__F_R9sDuration9sDuration_autogen___1((&___ret__9sDuration_1), (*___dst__R9sDuration_1)));
     145    return ___ret__9sDuration_1;
     146}
     147static inline void ___constructor__F_R9sDurationq_autogen___1(struct Duration *___dst__R9sDuration_1, signed long long int __tv__q_1){
     148    ((void)((*___dst__R9sDuration_1).__tv__q_1=__tv__q_1) /* ?{} */);
     149}
     150static inline void ___constructor__F_R9sDuration__1(struct Duration *__dur__R9sDuration_1){
     151    ((void)((*__dur__R9sDuration_1).__tv__q_1) /* ?{} */);
     152    ((void)((*__dur__R9sDuration_1).__tv__q_1=((signed long long int )0)));
     153}
     154static inline void ___constructor__F_R9sDurationZ__1(struct Duration *__dur__R9sDuration_1, long int __anonymous_object1351){
     155    ((void)((*__dur__R9sDuration_1).__tv__q_1) /* ?{} */);
     156    ((void)((*__dur__R9sDuration_1).__tv__q_1=((signed long long int )0)));
     157}
     158struct Time {
     159    unsigned long long int __tv__Uq_1;
     160};
     161static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
     162static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
     163static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
     164static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
     165static inline void ___constructor__F_R5sTimeUq_autogen___1(struct Time *___dst__R5sTime_1, unsigned long long int __tv__Uq_1);
     166static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     167    ((void)((*___dst__R5sTime_1).__tv__Uq_1) /* ?{} */);
     168}
     169static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
     170    ((void)((*___dst__R5sTime_1).__tv__Uq_1=___src__5sTime_1.__tv__Uq_1) /* ?{} */);
     171}
     172static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     173    ((void)((*___dst__R5sTime_1).__tv__Uq_1) /* ^?{} */);
     174}
     175static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
     176    struct Time ___ret__5sTime_1;
     177    ((void)((*___dst__R5sTime_1).__tv__Uq_1=___src__5sTime_1.__tv__Uq_1));
     178    ((void)___constructor__F_R5sTime5sTime_autogen___1((&___ret__5sTime_1), (*___dst__R5sTime_1)));
     179    return ___ret__5sTime_1;
     180}
     181static inline void ___constructor__F_R5sTimeUq_autogen___1(struct Time *___dst__R5sTime_1, unsigned long long int __tv__Uq_1){
     182    ((void)((*___dst__R5sTime_1).__tv__Uq_1=__tv__Uq_1) /* ?{} */);
     183}
     184static inline void ___constructor__F_R5sTime__1(struct Time *__time__R5sTime_1){
     185    ((void)((*__time__R5sTime_1).__tv__Uq_1) /* ?{} */);
     186    ((void)((*__time__R5sTime_1).__tv__Uq_1=((unsigned long long int )0)));
     187}
     188static inline void ___constructor__F_R5sTimeZ__1(struct Time *__time__R5sTime_1, long int __anonymous_object1352){
     189    ((void)((*__time__R5sTime_1).__tv__Uq_1) /* ?{} */);
     190    ((void)((*__time__R5sTime_1).__tv__Uq_1=((unsigned long long int )0)));
     191}
     192void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd09sDuration__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1353), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1354), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1355, _Bool __anonymous_object1356), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1357), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1358, const char *__anonymous_object1359), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1360), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1361, _Bool __anonymous_object1362), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1363), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1364), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1365), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1366), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1367), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1368, const char *__anonymous_object1369), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1370), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1371, const char *__anonymous_object1372), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1373), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1374), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1375, const char *__anonymous_object1376, unsigned long int __anonymous_object1377), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1378, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Duration __dur__9sDuration_1);
     193void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd05sTime__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1379), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1380), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1381, _Bool __anonymous_object1382), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1383), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1384, const char *__anonymous_object1385), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1386), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1387, _Bool __anonymous_object1388), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1389), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1390), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1391), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1392), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1393), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1394, const char *__anonymous_object1395), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1396), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1397, const char *__anonymous_object1398), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1399), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1400), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1401, const char *__anonymous_object1402, unsigned long int __anonymous_object1403), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1404, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Time __time__5sTime_1);
    124194enum __anonymous0 {
    125195    __sepSize__C13e__anonymous0_1 = 16,
    … …  
    401471
    402472}
    403 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1351);
    404 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1352);
    405 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1353, _Bool __anonymous_object1354);
    406 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1355);
    407 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1356, const char *__anonymous_object1357);
    408 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1358);
    409 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1359, _Bool __anonymous_object1360);
    410 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1361);
    411 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1362);
    412 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1363);
    413 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1364);
    414 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1365);
    415 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1366, const char *__anonymous_object1367);
    416 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1368);
    417 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1369, const char *__anonymous_object1370);
    418 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1371);
    419 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1372);
    420 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1373, const char *__name__PCc_1, const char *__mode__PCc_1);
    421 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1374, const char *__name__PCc_1);
    422 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1375);
    423 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1376, const char *__data__PCc_1, unsigned long int __size__Ul_1);
    424 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1377, const char *__fmt__PCc_1, ...);
     473_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1405);
     474void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1406);
     475void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1407, _Bool __anonymous_object1408);
     476const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1409);
     477void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1410, const char *__anonymous_object1411);
     478_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1412);
     479void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1413, _Bool __anonymous_object1414);
     480void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1415);
     481void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1416);
     482_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1417);
     483_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1418);
     484const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1419);
     485void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1420, const char *__anonymous_object1421);
     486const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1422);
     487void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1423, const char *__anonymous_object1424);
     488signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1425);
     489signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1426);
     490void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1427, const char *__name__PCc_1, const char *__mode__PCc_1);
     491void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1428, const char *__name__PCc_1);
     492void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1429);
     493struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1430, const char *__data__PCc_1, unsigned long int __size__Ul_1);
     494signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1431, const char *__fmt__PCc_1, ...);
    425495void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1);
    426496void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    … …  
    461531struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
    462532struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1);
    463 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1378, const char *__fmt__PCc_1, ...);
     533signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1432, const char *__fmt__PCc_1, ...);
    464534void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
    465535void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    … …  
    471541    struct ofstream *_tmp_cp_ret4;
    472542    __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
    473         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1379))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1380))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1381, _Bool __anonymous_object1382))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1383))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1384, const char *__anonymous_object1385))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1386))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1387, _Bool __anonymous_object1388))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1389))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1390))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1391))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1392))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1393))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1396))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1397, const char *__anonymous_object1398))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1399))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1400))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1401, const char *__anonymous_object1402, unsigned long int __anonymous_object1403))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1404, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    474     }
    475     ((void)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1405))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1406))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1407, _Bool __anonymous_object1408))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1409))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1410, const char *__anonymous_object1411))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1412))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1413, _Bool __anonymous_object1414))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1415))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1416))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1417))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1418))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1419))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1422))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1423, const char *__anonymous_object1424))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1425))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1426))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1427, const char *__anonymous_object1428, unsigned long int __anonymous_object1429))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1430, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1431))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1432))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1433, _Bool __anonymous_object1434))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1435))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1436, const char *__anonymous_object1437))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1438))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1439, _Bool __anonymous_object1440))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1441))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1442))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1443))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1444))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1445))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1448))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1449, const char *__anonymous_object1450))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1451))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1452))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1453, const char *__anonymous_object1454, unsigned long int __anonymous_object1455))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1456, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1457))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1458))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1459, _Bool __anonymous_object1460))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1461))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1462, const char *__anonymous_object1463))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1464))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1465, _Bool __anonymous_object1466))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1467))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1468))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1469))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1470))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1471))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1474))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1475, const char *__anonymous_object1476))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1477))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1478))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1479, const char *__anonymous_object1480, unsigned long int __anonymous_object1481))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1482, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret2)), __v__c_1)))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1483))(&_thunk0)))))) , _tmp_cp_ret4));
     543        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1433))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1434))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1437))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1438, const char *__anonymous_object1439))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1440))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1441, _Bool __anonymous_object1442))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1443))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1444))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1445))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1446))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1447))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1448, const char *__anonymous_object1449))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1450))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1451, const char *__anonymous_object1452))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1453))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1454))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1455, const char *__anonymous_object1456, unsigned long int __anonymous_object1457))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1458, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     544    }
     545    ((void)(((void)(_tmp_cp_ret4=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1459))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1460))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1463))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1464, const char *__anonymous_object1465))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1466))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1467, _Bool __anonymous_object1468))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1469))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1470))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1471))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1472))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1473))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1474, const char *__anonymous_object1475))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1476))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1477, const char *__anonymous_object1478))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1479))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1480))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1481, const char *__anonymous_object1482, unsigned long int __anonymous_object1483))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1484, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1485))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1486))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1489))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1490, const char *__anonymous_object1491))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1492))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1493, _Bool __anonymous_object1494))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1495))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1496))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1497))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1498))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1499))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1500, const char *__anonymous_object1501))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1502))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1503, const char *__anonymous_object1504))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1505))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1506))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1507, const char *__anonymous_object1508, unsigned long int __anonymous_object1509))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1510, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1511))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1512))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1515))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1516, const char *__anonymous_object1517))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1518))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1519, _Bool __anonymous_object1520))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1521))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1522))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1523))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1524))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1525))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1526, const char *__anonymous_object1527))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1528))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1529, const char *__anonymous_object1530))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1531))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1532))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1533, const char *__anonymous_object1534, unsigned long int __anonymous_object1535))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1536, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret2)), __v__c_1)))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1537))(&_thunk0)))))) , _tmp_cp_ret4));
    476546}
    477547void __f__F_Sc__1(signed char __v__Sc_1){
    … …  
    480550    struct ofstream *_tmp_cp_ret7;
    481551    __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
    482         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1484))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1485))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1486, _Bool __anonymous_object1487))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1488))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1489, const char *__anonymous_object1490))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1491))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1492, _Bool __anonymous_object1493))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1494))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1495))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1496))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1497))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1498))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1501))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1502, const char *__anonymous_object1503))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1504))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1505))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1506, const char *__anonymous_object1507, unsigned long int __anonymous_object1508))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1509, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    483     }
    484     ((void)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1510))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1511))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1512, _Bool __anonymous_object1513))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1514))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1515, const char *__anonymous_object1516))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1517))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1518, _Bool __anonymous_object1519))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1520))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1521))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1522))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1523))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1524))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1527))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1528, const char *__anonymous_object1529))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1530))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1531))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1532, const char *__anonymous_object1533, unsigned long int __anonymous_object1534))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1535, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1536))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1537))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1538, _Bool __anonymous_object1539))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1540))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1541, const char *__anonymous_object1542))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1543))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1544, _Bool __anonymous_object1545))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1546))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1547))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1548))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1549))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1550))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1553))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1554, const char *__anonymous_object1555))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1556))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1557))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1558, const char *__anonymous_object1559, unsigned long int __anonymous_object1560))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1561, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1562))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1563))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1564, _Bool __anonymous_object1565))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1566))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1567, const char *__anonymous_object1568))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1569))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1570, _Bool __anonymous_object1571))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1572))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1573))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1574))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1575))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1576))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1579))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1580, const char *__anonymous_object1581))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1582))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1583))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1584, const char *__anonymous_object1585, unsigned long int __anonymous_object1586))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1587, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret5)), __v__Sc_1)))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1588))(&_thunk1)))))) , _tmp_cp_ret7));
     552        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1538))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1539))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1542))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1543, const char *__anonymous_object1544))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1545))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1546, _Bool __anonymous_object1547))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1548))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1549))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1550))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1551))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1552))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1553, const char *__anonymous_object1554))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1555))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1556, const char *__anonymous_object1557))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1558))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1559))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1560, const char *__anonymous_object1561, unsigned long int __anonymous_object1562))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1563, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     553    }
     554    ((void)(((void)(_tmp_cp_ret7=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1564))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1565))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1568))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1569, const char *__anonymous_object1570))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1571))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1572, _Bool __anonymous_object1573))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1574))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1575))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1576))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1577))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1578))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1579, const char *__anonymous_object1580))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1581))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1582, const char *__anonymous_object1583))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1584))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1585))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1586, const char *__anonymous_object1587, unsigned long int __anonymous_object1588))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1589, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1590))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1591))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1594))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1595, const char *__anonymous_object1596))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1597))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1598, _Bool __anonymous_object1599))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1600))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1601))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1602))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1603))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1604))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1605, const char *__anonymous_object1606))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1607))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1608, const char *__anonymous_object1609))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1610))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1611))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1612, const char *__anonymous_object1613, unsigned long int __anonymous_object1614))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1615, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1616))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1617))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1620))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1621, const char *__anonymous_object1622))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1623))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1624, _Bool __anonymous_object1625))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1626))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1627))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1628))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1629))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1630))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1631, const char *__anonymous_object1632))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1633))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1634, const char *__anonymous_object1635))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1636))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1637))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1638, const char *__anonymous_object1639, unsigned long int __anonymous_object1640))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1641, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret5)), __v__Sc_1)))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1642))(&_thunk1)))))) , _tmp_cp_ret7));
    485555}
    486556void __f__F_Uc__1(unsigned char __v__Uc_1){
    … …  
    489559    struct ofstream *_tmp_cp_ret10;
    490560    __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
    491         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1589))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1590))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1591, _Bool __anonymous_object1592))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1593))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1594, const char *__anonymous_object1595))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1596))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1597, _Bool __anonymous_object1598))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1599))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1600))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1601))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1602))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1603))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1606))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1607, const char *__anonymous_object1608))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1609))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1610))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1611, const char *__anonymous_object1612, unsigned long int __anonymous_object1613))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1614, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    492     }
    493     ((void)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1615))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1616))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1617, _Bool __anonymous_object1618))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1619))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1620, const char *__anonymous_object1621))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1622))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1623, _Bool __anonymous_object1624))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1625))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1626))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1627))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1628))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1629))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1632))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1633, const char *__anonymous_object1634))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1635))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1636))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1637, const char *__anonymous_object1638, unsigned long int __anonymous_object1639))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1640, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1641))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1642))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1643, _Bool __anonymous_object1644))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1645))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1646, const char *__anonymous_object1647))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1648))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1649, _Bool __anonymous_object1650))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1651))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1652))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1653))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1654))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1655))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1658))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1659, const char *__anonymous_object1660))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1661))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1662))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1663, const char *__anonymous_object1664, unsigned long int __anonymous_object1665))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1666, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1667))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1668))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1669, _Bool __anonymous_object1670))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1671))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1672, const char *__anonymous_object1673))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1674))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1675, _Bool __anonymous_object1676))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1677))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1678))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1679))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1680))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1681))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1684))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1685, const char *__anonymous_object1686))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1687))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1688))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1689, const char *__anonymous_object1690, unsigned long int __anonymous_object1691))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1692, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret8)), __v__Uc_1)))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1693))(&_thunk2)))))) , _tmp_cp_ret10));
     561        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1643))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1644))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1647))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1648, const char *__anonymous_object1649))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1650))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1651, _Bool __anonymous_object1652))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1653))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1654))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1655))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1656))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1657))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1658, const char *__anonymous_object1659))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1660))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1661, const char *__anonymous_object1662))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1663))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1664))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1665, const char *__anonymous_object1666, unsigned long int __anonymous_object1667))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1668, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     562    }
     563    ((void)(((void)(_tmp_cp_ret10=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1669))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1670))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1673))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1674, const char *__anonymous_object1675))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1676))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1677, _Bool __anonymous_object1678))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1679))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1680))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1681))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1682))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1683))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1684, const char *__anonymous_object1685))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1686))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1687, const char *__anonymous_object1688))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1689))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1690))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1691, const char *__anonymous_object1692, unsigned long int __anonymous_object1693))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1694, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1695))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1696))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1699))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1700, const char *__anonymous_object1701))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1702))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1703, _Bool __anonymous_object1704))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1705))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1706))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1707))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1708))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1709))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1710, const char *__anonymous_object1711))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1712))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1713, const char *__anonymous_object1714))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1715))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1716))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1717, const char *__anonymous_object1718, unsigned long int __anonymous_object1719))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1720, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1721))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1722))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1725))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1726, const char *__anonymous_object1727))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1728))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1729, _Bool __anonymous_object1730))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1731))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1732))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1733))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1734))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1735))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1736, const char *__anonymous_object1737))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1738))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1739, const char *__anonymous_object1740))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1741))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1742))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1743, const char *__anonymous_object1744, unsigned long int __anonymous_object1745))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1746, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret8)), __v__Uc_1)))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1747))(&_thunk2)))))) , _tmp_cp_ret10));
    494564}
    495565void __f__F_s__1(signed short int __v__s_1){
    … …  
    498568    struct ofstream *_tmp_cp_ret13;
    499569    __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
    500         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1694))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1695))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1696, _Bool __anonymous_object1697))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1698))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1699, const char *__anonymous_object1700))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1701))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1702, _Bool __anonymous_object1703))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1704))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1705))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1706))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1707))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1708))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1711))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1712, const char *__anonymous_object1713))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1714))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1715))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1716, const char *__anonymous_object1717, unsigned long int __anonymous_object1718))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1719, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    501     }
    502     ((void)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1720))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1721))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1722, _Bool __anonymous_object1723))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1724))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1725, const char *__anonymous_object1726))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1727))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1728, _Bool __anonymous_object1729))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1730))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1731))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1732))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1733))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1734))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1737))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1738, const char *__anonymous_object1739))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1740))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1741))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1742, const char *__anonymous_object1743, unsigned long int __anonymous_object1744))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1745, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1746))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1747))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1748, _Bool __anonymous_object1749))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1750))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1751, const char *__anonymous_object1752))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1753))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1754, _Bool __anonymous_object1755))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1756))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1757))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1758))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1759))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1760))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1763))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1764, const char *__anonymous_object1765))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1766))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1767))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1768, const char *__anonymous_object1769, unsigned long int __anonymous_object1770))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1771, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1772))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1773))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1774, _Bool __anonymous_object1775))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1776))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1777, const char *__anonymous_object1778))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1779))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1780, _Bool __anonymous_object1781))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1782))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1783))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1784))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1785))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1786))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1789))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1790, const char *__anonymous_object1791))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1792))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1793))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1794, const char *__anonymous_object1795, unsigned long int __anonymous_object1796))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1797, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret11)), __v__s_1)))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1798))(&_thunk3)))))) , _tmp_cp_ret13));
     570        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1748))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1749))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1752))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1753, const char *__anonymous_object1754))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1755))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1756, _Bool __anonymous_object1757))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1758))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1759))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1760))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1761))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1762))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1763, const char *__anonymous_object1764))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1765))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1766, const char *__anonymous_object1767))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1768))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1769))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1770, const char *__anonymous_object1771, unsigned long int __anonymous_object1772))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1773, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     571    }
     572    ((void)(((void)(_tmp_cp_ret13=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1774))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1775))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1778))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1779, const char *__anonymous_object1780))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1781))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1782, _Bool __anonymous_object1783))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1784))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1785))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1786))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1787))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1788))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1789, const char *__anonymous_object1790))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1791))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1792, const char *__anonymous_object1793))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1794))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1795))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1796, const char *__anonymous_object1797, unsigned long int __anonymous_object1798))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1799, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1800))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1801))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1804))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1805, const char *__anonymous_object1806))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1807))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1808, _Bool __anonymous_object1809))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1810))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1811))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1812))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1813))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1814))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1815, const char *__anonymous_object1816))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1817))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1818, const char *__anonymous_object1819))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1820))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1821))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1822, const char *__anonymous_object1823, unsigned long int __anonymous_object1824))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1825, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1826))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1827))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1830))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1831, const char *__anonymous_object1832))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1833))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1834, _Bool __anonymous_object1835))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1836))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1837))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1838))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1839))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1840))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1841, const char *__anonymous_object1842))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1843))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1844, const char *__anonymous_object1845))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1846))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1847))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1848, const char *__anonymous_object1849, unsigned long int __anonymous_object1850))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1851, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret11)), __v__s_1)))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1852))(&_thunk3)))))) , _tmp_cp_ret13));
    503573}
    504574void __f__F_Us__1(unsigned short int __v__Us_1){
    … …  
    507577    struct ofstream *_tmp_cp_ret16;
    508578    __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
    509         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1799))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1800))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1801, _Bool __anonymous_object1802))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1803))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1804, const char *__anonymous_object1805))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1806))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1807, _Bool __anonymous_object1808))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1809))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1810))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1811))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1812))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1813))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1816))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1817, const char *__anonymous_object1818))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1819))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1820))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1821, const char *__anonymous_object1822, unsigned long int __anonymous_object1823))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1824, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    510     }
    511     ((void)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1825))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1826))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1827, _Bool __anonymous_object1828))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1829))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1830, const char *__anonymous_object1831))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1832))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1833, _Bool __anonymous_object1834))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1835))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1836))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1837))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1838))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1839))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1842))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1843, const char *__anonymous_object1844))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1845))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1846))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1847, const char *__anonymous_object1848, unsigned long int __anonymous_object1849))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1850, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1851))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1852))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1853, _Bool __anonymous_object1854))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1855))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1856, const char *__anonymous_object1857))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1858))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1859, _Bool __anonymous_object1860))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1861))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1862))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1863))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1864))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1865))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1868))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1869, const char *__anonymous_object1870))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1871))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1872))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1873, const char *__anonymous_object1874, unsigned long int __anonymous_object1875))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1876, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1877))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1878))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1879, _Bool __anonymous_object1880))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1881))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1882, const char *__anonymous_object1883))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1884))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1885, _Bool __anonymous_object1886))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1887))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1888))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1889))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1890))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1891))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1894))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1895, const char *__anonymous_object1896))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1897))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1898))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1899, const char *__anonymous_object1900, unsigned long int __anonymous_object1901))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1902, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret14)), __v__Us_1)))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1903))(&_thunk4)))))) , _tmp_cp_ret16));
     579        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1853))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1854))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1857))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1858, const char *__anonymous_object1859))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1860))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1861, _Bool __anonymous_object1862))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1863))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1864))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1865))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1866))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1867))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1868, const char *__anonymous_object1869))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1870))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1871, const char *__anonymous_object1872))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1873))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1874))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1875, const char *__anonymous_object1876, unsigned long int __anonymous_object1877))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1878, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     580    }
     581    ((void)(((void)(_tmp_cp_ret16=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1879))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1880))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1883))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1884, const char *__anonymous_object1885))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1886))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1887, _Bool __anonymous_object1888))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1889))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1890))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1891))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1892))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1893))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1894, const char *__anonymous_object1895))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1896))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1897, const char *__anonymous_object1898))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1899))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1900))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1901, const char *__anonymous_object1902, unsigned long int __anonymous_object1903))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1904, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1905))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1906))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1909))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1910, const char *__anonymous_object1911))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1912))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1913, _Bool __anonymous_object1914))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1915))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1916))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1917))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1918))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1919))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1920, const char *__anonymous_object1921))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1922))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1923, const char *__anonymous_object1924))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1925))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1926))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1927, const char *__anonymous_object1928, unsigned long int __anonymous_object1929))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1930, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1931))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1932))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1935))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1936, const char *__anonymous_object1937))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1938))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1939, _Bool __anonymous_object1940))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1941))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1942))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1943))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1944))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1945))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1946, const char *__anonymous_object1947))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1948))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1949, const char *__anonymous_object1950))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1951))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1952))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1953, const char *__anonymous_object1954, unsigned long int __anonymous_object1955))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1956, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret14)), __v__Us_1)))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1957))(&_thunk4)))))) , _tmp_cp_ret16));
    512582}
    513583void __f__F_Ui__1(unsigned int __v__Ui_1){
    … …  
    516586    struct ofstream *_tmp_cp_ret19;
    517587    __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
    518         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1904))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1905))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1906, _Bool __anonymous_object1907))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1908))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1909, const char *__anonymous_object1910))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1911))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1912, _Bool __anonymous_object1913))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1914))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1915))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1916))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1917))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1918))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1921))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1922, const char *__anonymous_object1923))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1924))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1925))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1926, const char *__anonymous_object1927, unsigned long int __anonymous_object1928))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1929, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    519     }
    520     ((void)(((void)(_tmp_cp_ret19=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1930))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1931))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1932, _Bool __anonymous_object1933))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1934))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1935, const char *__anonymous_object1936))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1937))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1938, _Bool __anonymous_object1939))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1940))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1941))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1942))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1943))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1944))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1947))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1948, const char *__anonymous_object1949))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1950))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1951))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1952, const char *__anonymous_object1953, unsigned long int __anonymous_object1954))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1955, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(((_Bool (*)(void *__anonymous_object1956))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1957))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1958, _Bool __anonymous_object1959))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1960))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1961, const char *__anonymous_object1962))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1963))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1964, _Bool __anonymous_object1965))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1966))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1967))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1968))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1969))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1970))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1973))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1974, const char *__anonymous_object1975))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1976))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1977))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1978, const char *__anonymous_object1979, unsigned long int __anonymous_object1980))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1981, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1982))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1983))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1984, _Bool __anonymous_object1985))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1986))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1987, const char *__anonymous_object1988))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1989))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1990, _Bool __anonymous_object1991))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1992))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1993))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1994))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1995))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1996))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1997, const char *__anonymous_object1998))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1999))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2000, const char *__anonymous_object2001))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2002))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2003))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2004, const char *__anonymous_object2005, unsigned long int __anonymous_object2006))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2007, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret17)), __v__Ui_1)))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object2008))(&_thunk5)))))) , _tmp_cp_ret19));
     588        return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1958))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1959))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1960, _Bool __anonymous_object1961))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1962))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1963, const char *__anonymous_object1964))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1965))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1966, _Bool __anonymous_object1967))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1968))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1969))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1970))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1971))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1972))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1973, const char *__anonymous_object1974))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1975))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1976, const char *__anonymous_object1977))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1978))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1979))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1980, const char *__anonymous_object1981, unsigned long int __anonymous_object1982))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1983, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     589    }
     590    ((void)(((void)(_tmp_cp_ret19=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1984))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1985))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1986, _Bool __anonymous_object1987))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1988))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1989, const char *__anonymous_object1990))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1991))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1992, _Bool __anonymous_object1993))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1994))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1995))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1996))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1997))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1998))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1999, const char *__anonymous_object2000))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object2001))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2002, const char *__anonymous_object2003))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2004))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2005))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2006, const char *__anonymous_object2007, unsigned long int __anonymous_object2008))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2009, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(((_Bool (*)(void *__anonymous_object2010))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2011))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object2012, _Bool __anonymous_object2013))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object2014))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2015, const char *__anonymous_object2016))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object2017))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2018, _Bool __anonymous_object2019))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object2020))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object2021))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2022))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2023))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object2024))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2025, const char *__anonymous_object2026))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object2027))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2028, const char *__anonymous_object2029))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2030))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2031))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2032, const char *__anonymous_object2033, unsigned long int __anonymous_object2034))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2035, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=((struct ofstream *)___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object2036))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2037))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object2038, _Bool __anonymous_object2039))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object2040))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2041, const char *__anonymous_object2042))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object2043))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object2044, _Bool __anonymous_object2045))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object2046))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object2047))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2048))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object2049))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object2050))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2051, const char *__anonymous_object2052))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object2053))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object2054, const char *__anonymous_object2055))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object2056))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object2057))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object2058, const char *__anonymous_object2059, unsigned long int __anonymous_object2060))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object2061, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret17)), __v__Ui_1)))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object2062))(&_thunk5)))))) , _tmp_cp_ret19));
    521591}
    522592signed int __main__Fi___1(){

  • src/tests/.expect/references.txt

    rb2fe1c9 r32cab5b  
    4413 1 12
    5514 14
     6x = 6 ; x2 = 789
     7x = 6 ; x2 = 999
     8x = 12345 ; x2 = 999
     9x = 22222 ; x2 = 999
    610Default constructing a Y
    711Copy constructing a Y
    … …  
    2832Destructing a Y
    2933Destructing a Y
     343 3
     353
     363
     373 9 { 1, 7 }, [1, 2, 3]
    3038Destructing a Y
    3139Destructing a Y

  • src/tests/Makefile.am

    rb2fe1c9 r32cab5b  
    110110        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    111111
     112fallthrough-ERROR: fallthrough.c @CFA_BINDIR@/@CFA_NAME@
     113        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     114
    112115# Constructor/destructor tests
    113116raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@

  • src/tests/Makefile.in

    rb2fe1c9 r32cab5b  
    787787        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    788788
     789fallthrough-ERROR: fallthrough.c @CFA_BINDIR@/@CFA_NAME@
     790        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     791
    789792# Constructor/destructor tests
    790793raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@

  • src/tests/concurrent/examples/datingService.c

    rb2fe1c9 r32cab5b  
    88// Created On       : Mon Oct 30 12:56:20 2017
    99// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Tue Jan  2 12:19:01 2018
    11 // Update Count     : 22
     10// Last Modified On : Wed Mar 14 22:48:40 2018
     11// Update Count     : 23
    1212//
    1313
    … …  
    8888int main() {
    8989        DatingService TheExchange;
    90         Girl *girls[NoOfPairs];
    91         Boy  *boys[NoOfPairs];
     90        Girl * girls[NoOfPairs];
     91        Boy  * boys[NoOfPairs];
    9292
    9393        srandom( /*getpid()*/ 103 );

  • src/tests/concurrent/preempt.c

    rb2fe1c9 r32cab5b  
    11#include <kernel>
    22#include <thread>
     3#include <time>
    34
    45#ifndef PREEMPTION_RATE
    5 #define PREEMPTION_RATE 10_000ul
     6#define PREEMPTION_RATE 10`ms
    67#endif
    78
    8 unsigned int default_preemption() {
     9Duration default_preemption() {
    910        return PREEMPTION_RATE;
    1011}

  • src/tests/concurrent/signal/barge.c

    rb2fe1c9 r32cab5b  
    1616
    1717#ifndef PREEMPTION_RATE
    18 #define PREEMPTION_RATE 10_000ul
     18#define PREEMPTION_RATE 10`ms
    1919#endif
    2020
    21 unsigned int default_preemption() {
     21Duration default_preemption() {
    2222        return 0;
    2323}

  • src/tests/concurrent/signal/block.c

    rb2fe1c9 r32cab5b  
    1212#include <stdlib>
    1313#include <thread>
    14 
    15 #include <time.h>
     14#include <time>
    1615
    1716#ifdef LONG_TEST
    … …  
    2221
    2322#ifndef PREEMPTION_RATE
    24 #define PREEMPTION_RATE 10_000ul
     23#define PREEMPTION_RATE 10`ms
    2524#endif
    2625
    27 unsigned int default_preemption() {
     26Duration default_preemption() {
    2827        return PREEMPTION_RATE;
    2928}
    … …  
    5150//------------------------------------------------------------------------------
    5251void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
    53         wait( cond, (uintptr_t)this_thread );
     52    wait( cond, (uintptr_t)active_thread() );
    5453
    5554        yield( random( 10 ) );
    … …  
    6059        }
    6160
    62         a.last_thread = b.last_thread = this_thread;
     61        a.last_thread = b.last_thread = active_thread();
    6362
    6463        yield( random( 10 ) );
    … …  
    7675        yield( random( 10 ) );
    7776
    78         [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
     77        [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = active_thread();
    7978
    8079        if( !is_empty( cond ) ) {
    … …  
    106105//------------------------------------------------------------------------------
    107106void barge_op( global_data_t & mutex a ) {
    108         a.last_thread = this_thread;
     107        a.last_thread = active_thread();
    109108}
    110109

  • src/tests/concurrent/signal/disjoint.c

    rb2fe1c9 r32cab5b  
    33#include <monitor>
    44#include <thread>
    5 
    6 #include <time.h>
     5#include <time>
    76
    87#ifdef LONG_TEST
    … …  
    1312
    1413#ifndef PREEMPTION_RATE
    15 #define PREEMPTION_RATE 10_000ul
     14#define PREEMPTION_RATE 10`ms
    1615#endif
    1716
    18 unsigned int default_preemption() {
     17Duration default_preemption() {
    1918        return PREEMPTION_RATE;
    2019}

  • src/tests/concurrent/signal/wait.c

    rb2fe1c9 r32cab5b  
    1010#include <stdlib>
    1111#include <thread>
    12 
    13 #include <time.h>
     12#include <time>
    1413
    1514#ifdef LONG_TEST
    … …  
    2019
    2120#ifndef PREEMPTION_RATE
    22 #define PREEMPTION_RATE 10_000ul
     21#define PREEMPTION_RATE 10`ms
    2322#endif
    2423
    25 unsigned int default_preemption() {
     24Duration default_preemption() {
    2625        return PREEMPTION_RATE;
    2726}

  • src/tests/concurrent/waitfor/simple.c

    rb2fe1c9 r32cab5b  
    1010
    1111#ifndef PREEMPTION_RATE
    12 #define PREEMPTION_RATE 10_000ul
     12#define PREEMPTION_RATE 10`ms
    1313#endif
    1414
    15 unsigned int default_preemption() {
     15Duration default_preemption() {
    1616        return PREEMPTION_RATE;
    1717}

  • src/tests/coroutine/fibonacci.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Thu Jun  8 07:29:37 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec  5 22:27:54 2017
    13 // Update Count     : 14
     12// Last Modified On : Thu Mar 22 22:45:44 2018
     13// Update Count     : 15
    1414//
    1515
    … …  
    2121void ?{}( Fibonacci & fib ) with( fib ) { fn = 0; }
    2222
     23// main automatically called on first resume
    2324void main( Fibonacci & fib ) with( fib ) {
    2425        int fn1, fn2;                                                                           // retained between resumes
    25 
    26         fn = 0; fn1 = fn;                                                                       // 1st case
     26        fn = 0;  fn1 = fn;                                                                      // 1st case
    2727        suspend();                                                                                      // restart last resume
    28 
    29         fn = 1; fn2 = fn1;  fn1 = fn;                                           // 2nd case
     28        fn = 1;  fn2 = fn1;  fn1 = fn;                                          // 2nd case
    3029        suspend();                                                                                      // restart last resume
    31 
    3230        for ( ;; ) {
    3331                fn = fn1 + fn2; fn2 = fn1;  fn1 = fn;                   // general case

  • src/tests/minmax.c

    rb2fe1c9 r32cab5b  
    77// minmax.c --
    88//
    9 // Author           : Richard C. Bilson
     9// Author           : Peter A. Buhr
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Feb 29 23:45:16 2016
    13 // Update Count     : 49
     12// Last Modified On : Tue Apr 10 17:29:09 2018
     13// Update Count     : 50
    1414//
    1515

  • src/tests/operators.c

    rb2fe1c9 r32cab5b  
    2727        a(b);
    2828        a + b;
    29         struct accumulator ?+?; // why not, eh?
    30         a + b;
    3129}
    3230

  • src/tests/preempt_longrun/create.c

    rb2fe1c9 r32cab5b  
    55
    66#ifndef PREEMPTION_RATE
    7 #define PREEMPTION_RATE 10_000ul
     7#define PREEMPTION_RATE 10`ms
    88#endif
    99
    10 unsigned int default_preemption() {
     10Duration default_preemption() {
    1111        return PREEMPTION_RATE;
    1212}

  • src/tests/preempt_longrun/enter.c

    rb2fe1c9 r32cab5b  
    66
    77#ifndef PREEMPTION_RATE
    8 #define PREEMPTION_RATE 10_000ul
     8#define PREEMPTION_RATE 10`ms
    99#endif
    1010
    11 unsigned int default_preemption() {
     11Duration default_preemption() {
    1212        return PREEMPTION_RATE;
    1313}

  • src/tests/preempt_longrun/enter3.c

    rb2fe1c9 r32cab5b  
    66
    77#ifndef PREEMPTION_RATE
    8 #define PREEMPTION_RATE 10_000ul
     8#define PREEMPTION_RATE 10`ms
    99#endif
    1010
    11 unsigned int default_preemption() {
     11Duration default_preemption() {
    1212        return PREEMPTION_RATE;
    1313}

  • src/tests/preempt_longrun/processor.c

    rb2fe1c9 r32cab5b  
    55
    66#ifndef PREEMPTION_RATE
    7 #define PREEMPTION_RATE 10_000ul
     7#define PREEMPTION_RATE 10`ms
    88#endif
    99
    10 unsigned int default_preemption() {
     10Duration default_preemption() {
    1111        return PREEMPTION_RATE;
    1212}

  • src/tests/preempt_longrun/stack.c

    rb2fe1c9 r32cab5b  
    55
    66#ifndef PREEMPTION_RATE
    7 #define PREEMPTION_RATE 10_000ul
     7#define PREEMPTION_RATE 10`ms
    88#endif
    99
    10 unsigned int default_preemption() {
     10Duration default_preemption() {
    1111        return PREEMPTION_RATE;
    1212}

  • src/tests/preempt_longrun/yield.c

    rb2fe1c9 r32cab5b  
    99
    1010#ifndef PREEMPTION_RATE
    11 #define PREEMPTION_RATE 10_000ul
     11#define PREEMPTION_RATE 10`ms
    1212#endif
    1313
    14 unsigned int default_preemption() {
     14Duration default_preemption() {
    1515        return PREEMPTION_RATE;
    1616}

  • src/tests/references.c

    rb2fe1c9 r32cab5b  
    4646
    4747int main() {
    48         int x = 123456, *p1 = &x, **p2 = &p1, ***p3 = &p2,
     48        int x = 123456, x2 = 789, *p1 = &x, **p2 = &p1, ***p3 = &p2,
    4949                &r1 = x,    &&r2 = r1,   &&&r3 = r2;
    5050        ***p3 = 3;                          // change x
    … …  
    5252        *p3 = &p1;                          // change p2
    5353        int y = 0, z = 11, & ar[3] = { x, y, z };    // initialize array of references
     54        // &ar[1] = &z;                        // change reference array element
     55        // typeof( ar[1] ) p;                  // is int, i.e., the type of referenced object
     56        // typeof( &ar[1] ) q;                 // is int &, i.e., the type of reference
     57        // sizeof( ar[1] ) == sizeof( int );   // is true, i.e., the size of referenced object
     58        // sizeof( &ar[1] ) == sizeof( int *); // is true, i.e., the size of a reference
    5459
     60        ((int*&)&r3) = &x;                  // change r1, (&*)**r3
     61        x = 3;
    5562        // test that basic reference properties are true - r1 should be an alias for x
    5663        printf("%d %d %d\n", x, r1, &x == &r1);
    … …  
    6875        printf("%d %d\n", r1, x);
    6976
     77        ((int&)r3) = 6;                       // change x, ***r3
     78        printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
     79        ((int*&)&r3) = &x2;                   // change r1 to refer to x2, (&*)**r3
     80        ((int&)r3) = 999;                     // modify x2
     81        printf("x = %d ; x2 = %d\n", x, x2);  // check that x2 was changed
     82        ((int**&)&&r3) = p2;                  // change r2, (&(&*)*)*r3
     83        ((int&)r3) = 12345;                   // modify x
     84        printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
     85        ((int***&)&&&r3) = p3;                // change r3 to p3, (&(&(&*)*)*)r3
     86        ((int&)r3) = 22222;                   // modify x
     87        printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
     88
    7089        // test that reference members are not implicitly constructed/destructed/assigned
    7190        X x1, x2 = x1;
    … …  
    7695        &z1.r = &z1r;
    7796        &z2.r = &z2r;
     97
    7898        z1 = z2;
     99
     100        // test rvalue-to-reference conversion
     101        {
     102                struct S { double x, y; };
     103                void f( int & i, int & j, S & s, int v[] ) {
     104                        printf("%d %d { %g, %g }, [%d, %d, %d]\n", i, j, s.[x, y], v[0], v[1], v[2]);
     105                }
     106                void g(int & i) { printf("%d\n", i); }
     107                void h(int &&& i) { printf("%d\n", i); }
     108
     109                int &&& r = 3;  // rvalue to reference
     110                int i = r;
     111                printf("%d %d\n", i, r);  // both 3
     112
     113                g( 3 );          // rvalue to reference
     114                h( (int &&&)3 ); // rvalue to reference
     115
     116                int a = 5, b = 4;
     117                f( 3, a + b, (S){ 1.0, 7.0 }, (int [3]){ 1, 2, 3 } ); // two rvalue to reference
     118        }
    79119}
    80120

  • src/tests/switch.c

    rb2fe1c9 r32cab5b  
    1010// Created On       : Tue Jul 12 06:50:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Aug 26 10:14:21 2017
    13 // Update Count     : 33
     12// Last Modified On : Thu Mar  8 07:33:05 2018
     13// Update Count     : 36
    1414//
    1515
    … …  
    8787                S s;
    8888          case 19:
    89           case 'A' ... 'Z':
    90           case 0 ... 6:
     89          case 'A'...'Z':
     90          case 0 ...6:                                                                          // space required, or lexed as decimal point
    9191          case 20, 30, 40:
    9292                i = 3;
    … …  
    9696          case 8~10:
    9797                f( 3 );
    98                 fallthru
     98                fallthru;
    9999          case 'd':
    100100                j = 5;
Note: See TracChangeset for help on using the changeset viewer.