Changeset 1cdfa82 for src


Ignore:
Timestamp:
Apr 25, 2018, 4:55:53 PM (8 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
new-env, with_gc
Children:
42107b4
Parents:
2efe4b8 (diff), 9d5fb67 (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 remote-tracking branch 'origin/master' into with_gc

Location:
src
Files:
16 added
4 deleted
97 edited
1 moved

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r2efe4b8 r1cdfa82  
    116116        }
    117117
    118         CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), endl( *this ) {}
     118        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), printExprTypes( printExprTypes ), endl( *this ) {}
    119119
    120120        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
    … …  
    159159        }
    160160
     161        // *** Expression
     162        void CodeGenerator::previsit( Expression * node ) {
     163                previsit( (BaseSyntaxNode *)node );
     164                GuardAction( [this, node](){
     165                        if ( printExprTypes ) {
     166                                output << " /* " << genType( node->result, "", pretty, genC ) << " */ ";
     167                        }
     168                } );
     169        }
     170
    161171        // *** Declarations
    162172        void CodeGenerator::postvisit( FunctionDecl * functionDecl ) {
    … …  
    203213
    204214        void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
    205                 genAttributes( aggDecl->get_attributes() );
    206 
    207215                if( ! aggDecl->get_parameters().empty() && ! genC ) {
    208216                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
    … …  
    213221                }
    214222
    215                 output << kind << aggDecl->get_name();
     223                output << kind;
     224                genAttributes( aggDecl->get_attributes() );
     225                output << aggDecl->get_name();
    216226
    217227                if ( aggDecl->has_body() ) {
    … …  
    298308                        output << " }";
    299309                }
     310        }
     311
     312        void CodeGenerator::postvisit( StaticAssertDecl * assertDecl ) {
     313                output << "_Static_assert(";
     314                assertDecl->condition->accept( *visitor );
     315                output << ", ";
     316                assertDecl->message->accept( *visitor );
     317                output << ")";
    300318        }
    301319
    … …  
    578596                        output << ")";
    579597                } // if
    580                 castExpr->get_arg()->accept( *visitor );
     598                castExpr->arg->accept( *visitor );
     599                output << ")";
     600        }
     601
     602        void CodeGenerator::postvisit( KeywordCastExpr * castExpr ) {
     603                assertf( ! genC, "KeywordCast should not reach code generation." );
     604                extension( castExpr );
     605                output << "((" << castExpr->targetString() << " &)";
     606                castExpr->arg->accept( *visitor );
    581607                output << ")";
    582608        }
    … …  
    928954                        output << "continue";
    929955                        break;
     956                  case BranchStmt::FallThrough:
     957                  case BranchStmt::FallThroughDefault:
     958                        assertf( ! genC, "fallthru should not reach code generation." );
     959                  output << "fallthru";
     960                        break;
    930961                } // switch
     962                // print branch target for labelled break/continue/fallthru in debug mode
     963                if ( ! genC && branchStmt->get_type() != BranchStmt::Goto ) {
     964                        if ( ! branchStmt->get_target().empty() ) {
     965                                output << " " << branchStmt->get_target();
     966                        } else if ( branchStmt->get_type() == BranchStmt::FallThrough ) {
     967                                output << " default";
     968                        }
     969                }
    931970                output << ";";
    932971        }

  • src/CodeGen/CodeGenerator.h

    r2efe4b8 r1cdfa82  
    2727
    2828namespace CodeGen {
    29         struct CodeGenerator : public WithShortCircuiting, public WithVisitorRef<CodeGenerator> {
     29        struct CodeGenerator : public WithShortCircuiting, public WithGuards, public WithVisitorRef<CodeGenerator> {
    3030          static int tabsize;
    3131
    32                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false );
     32                CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false );
    3333
    3434                //*** Turn off visit_children for all nodes
    … …  
    3838                void postvisit( BaseSyntaxNode * );
    3939
     40                //*** print type for all expressions
     41                void previsit( Expression * node );
     42
    4043                //*** Declaration
    4144                void postvisit( StructDecl * );
    4245                void postvisit( FunctionDecl * );
    4346                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 );
     47                void postvisit( UnionDecl * aggregateDecl );
     48                void postvisit( EnumDecl * aggregateDecl );
     49                void postvisit( TraitDecl * aggregateDecl );
     50                void postvisit( TypedefDecl * typeDecl );
     51                void postvisit( TypeDecl * typeDecl );
     52                void postvisit( StaticAssertDecl * assertDecl );
    4953
    5054                //*** Initializer
    … …  
    6569                void postvisit( LabelAddressExpr *addressExpr );
    6670                void postvisit( CastExpr *castExpr );
     71                void postvisit( KeywordCastExpr * castExpr );
    6772                void postvisit( VirtualCastExpr *castExpr );
    6873                void postvisit( UntypedMemberExpr *memberExpr );
    … …  
    139144                bool genC = false;    // true if output has to be C code
    140145                bool lineMarks = false;
     146                bool printExprTypes = false;
    141147        public:
    142148                LineEnder endl;

  • src/CodeGen/GenType.cc

    r2efe4b8 r1cdfa82  
    4848                void postvisit( ZeroType * zeroType );
    4949                void postvisit( OneType * oneType );
     50                void postvisit( TraitInstType * inst );
     51                void postvisit( TypeofType * typeof );
    5052
    5153          private:
    … …  
    289291        }
    290292
     293        void GenType::postvisit( TraitInstType * inst ) {
     294                assertf( ! genC, "Trait types should not reach code generation." );
     295                typeString = inst->name + " " + typeString;
     296                handleQualifiers( inst );
     297        }
     298
     299        void GenType::postvisit( TypeofType * typeof ) {
     300                std::ostringstream os;
     301                PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
     302                os << "typeof(";
     303                typeof->expr->accept( cg );
     304                os << ") " << typeString;
     305                typeString = os.str();
     306                handleQualifiers( typeof );
     307        }
     308
    291309        void GenType::handleQualifiers( Type * type ) {
    292310                if ( type->get_const() ) {

  • src/CodeGen/Generate.cc

    r2efe4b8 r1cdfa82  
    4646        } // namespace
    4747
    48         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks ) {
     48        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) {
    4949                cleanTree( translationUnit );
    5050
    51                 PassVisitor<CodeGenerator> cgv( os, pretty, generateC, lineMarks );
     51                PassVisitor<CodeGenerator> cgv( os, pretty, generateC, lineMarks, printExprTypes );
    5252                for ( auto & dcl : translationUnit ) {
    5353                        if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {
    … …  
    6666                        os << CodeGen::genPrettyType( type, "" );
    6767                } else {
    68                         PassVisitor<CodeGenerator> cgv( os, true, false, false );
     68                        PassVisitor<CodeGenerator> cgv( os, true, false, false, false );
    6969                        node->accept( cgv );
    7070                }

  • src/CodeGen/Generate.h

    r2efe4b8 r1cdfa82  
    2424namespace CodeGen {
    2525        /// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.)
    26         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false , bool lineMarks = false );
     26        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false , bool lineMarks = false, bool printTypeExpr = false );
    2727
    2828        /// Generate code for a single node -- helpful for debugging in gdb

  • src/CodeGen/OperatorTable.cc

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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(
     40                        decls,
     41                        std::cerr,
     42                        true /* doIntrinsics */,
     43                        true /* pretty */,
     44                        false /* generateC */,
     45                        false /* lineMarks */,
     46                        true /* printTypeExpr */
     47                );
    4048        #endif
    4149        } // dump
    4250
    43         static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) {
     51        static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
    4452        #ifdef DEBUG
    4553                std::list< Declaration * > decls;
    4654
    47                 filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) {
    48                         return ! LinkageSpec::isBuiltin( decl->get_linkage() );
     55                filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), [linkageFilter]( Declaration * decl ) {
     56                        return ! (decl->linkage & linkageFilter);
    4957                });
    5058

  • src/Common/ErrorObjects.h

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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;
    … …  
    9192        virtual void visit( NameExpr * nameExpr ) override final;
    9293        virtual void visit( CastExpr * castExpr ) override final;
     94        virtual void visit( KeywordCastExpr * castExpr ) override final;
    9395        virtual void visit( VirtualCastExpr * castExpr ) override final;
    9496        virtual void visit( AddressExpr * addressExpr ) override final;
    … …  
    163165        virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
    164166        virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
     167        virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
    165168
    166169        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;
    … …  
    187190        virtual Expression * mutate( UntypedExpr * untypedExpr ) override final;
    188191        virtual Expression * mutate( NameExpr * nameExpr ) override final;
    189         virtual Expression * mutate( AddressExpr * castExpr ) override final;
     192        virtual Expression * mutate( AddressExpr * addrExpr ) override final;
    190193        virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) override final;
    191194        virtual Expression * mutate( CastExpr * castExpr ) override final;
     195        virtual Expression * mutate( KeywordCastExpr * castExpr ) override final;
    192196        virtual Expression * mutate( VirtualCastExpr * castExpr ) override final;
    193197        virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override final;

  • src/Common/PassVisitor.impl.h

    r2efe4b8 r1cdfa82  
    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 >
    … …  
    12381260
    12391261//--------------------------------------------------------------------------
     1262// KeywordCastExpr
     1263template< typename pass_type >
     1264void PassVisitor< pass_type >::visit( KeywordCastExpr * node ) {
     1265        VISIT_START( node );
     1266
     1267        indexerScopedAccept( node->result, *this );
     1268        maybeAccept_impl        ( node->arg   , *this );
     1269
     1270        VISIT_END( node );
     1271}
     1272
     1273template< typename pass_type >
     1274Expression * PassVisitor< pass_type >::mutate( KeywordCastExpr * node ) {
     1275        MUTATE_START( node );
     1276
     1277        indexerScopedMutate( node->env   , *this );
     1278        indexerScopedMutate( node->result, *this );
     1279        maybeMutate_impl   ( node->arg   , *this );
     1280
     1281        MUTATE_END( Expression, node );
     1282}
     1283
     1284//--------------------------------------------------------------------------
    12401285// VirtualCastExpr
    12411286template< typename pass_type >
    … …  
    14911536        indexerScopedAccept( node->result, *this );
    14921537        maybeAccept_impl   ( node->type  , *this );
    1493         maybeAccept_impl   ( node->member, *this );
    14941538
    14951539        VISIT_END( node );
    … …  
    15031547        indexerScopedMutate( node->result, *this );
    15041548        maybeMutate_impl   ( node->type  , *this );
    1505         maybeMutate_impl   ( node->member, *this );
    15061549
    15071550        MUTATE_END( Expression, node );

  • src/Common/SemanticError.cc

    r2efe4b8 r1cdfa82  
    6868}
    6969
    70 void SemanticWarningImpl( CodeLocation location, Warning, const char * const fmt, ... ) {
    71         va_list args;
    72         va_start(args, fmt);
    73         std::string msg = fmtToString( fmt, args );
    74         va_end(args);
    75         std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl;
     70void SemanticWarningImpl( CodeLocation location, Warning warning, const char * const fmt, ... ) {
     71        Severity severity = WarningFormats[(int)warning].severity;
     72        switch(severity) {
     73        case Severity::Suppress :
     74                break;
     75        case Severity::Warn :
     76                {
     77                        va_list args;
     78                        va_start(args, fmt);
     79                        std::string msg = fmtToString( fmt, args );
     80                        va_end(args);
     81                        std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl;
     82                }
     83                break;
     84        case Severity::Error :
     85                {
     86                        va_list args;
     87                        va_start(args, fmt);
     88                        std::string msg = fmtToString( fmt, args );
     89                        va_end(args);
     90                        SemanticError(location, msg);
     91                }
     92                break;
     93        case Severity::Critical :
     94                assertf(false, "Critical errors not implemented yet");
     95                break;
     96        }
    7697}
    7798

  • src/Common/SemanticError.h

    r2efe4b8 r1cdfa82  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug 29 22:03:36 2017
    13 // Update Count     : 17
     12// Last Modified On : Thu Apr 19 17:52:03 2018
     13// Update Count     : 19
    1414//
    1515
    … …  
    3636// Warnings
    3737
    38 constexpr const char * const WarningFormats[] = {
    39         "self assignment of expression: %s",
     38enum class Severity {
     39        Suppress,
     40        Warn,
     41        Error,
     42        Critical
     43};
     44
     45struct WarningData {
     46        const char * const name;
     47        const char * const message;
     48        mutable Severity severity;
     49};
     50
     51constexpr const WarningData WarningFormats[] = {
     52        {"self-assign"         , "self assignment of expression: %s"           , Severity::Warn},
     53        {"reference-conversion", "rvalue to reference conversion of rvalue: %s", Severity::Warn},
     54        {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn},
    4055};
    4156
    4257enum class Warning {
    4358        SelfAssignment,
     59        RvalueToReferenceConversion,
     60        BadQualifiersZeroOne,
    4461        NUMBER_OF_WARNINGS, //This MUST be the last warning
    4562};
    … …  
    5067);
    5168
    52 #define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id], __VA_ARGS__)
     69#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id].message, __VA_ARGS__)
    5370
    5471void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4)));

  • src/Common/utility.h

    r2efe4b8 r1cdfa82  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Aug 17 11:38:00 2017
    13 // Update Count     : 34
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Fri Apr 20 22:35:33 2018
     13// Update Count     : 38
    1414//
    1515
    … …  
    433433}
    434434
     435// -----------------------------------------------------------------------------
     436// O(1) polymorphic integer ilog2, using clz, which returns the number of leading 0-bits, starting at the most
     437// significant bit (single instruction on x86)
     438
     439template<typename T>
     440inline constexpr T ilog2(const T & t) {
     441        if ( std::is_integral<T>::value ) {
     442                const constexpr int r = sizeof(t) * __CHAR_BIT__ - 1;
     443                if ( sizeof(T) == sizeof(unsigned int ) ) return r - __builtin_clz( t );
     444                if ( sizeof(T) == sizeof(unsigned long) ) return r - __builtin_clzl( t );
     445                if ( sizeof(T) == sizeof(unsigned long long) ) return r - __builtin_clzll( t );
     446        } // if
     447        return -1;
     448} // ilong2
    435449
    436450

  • src/Concurrency/Keywords.cc

    r2efe4b8 r1cdfa82  
    5454          public:
    5555
    56                 ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
    57                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
     56                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, KeywordCastExpr::Target cast_target ) :
     57                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
    5858
    5959                virtual ~ConcurrentSueKeyword() {}
    6060
    61                 void postvisit( StructDecl * decl );
     61                Declaration * postmutate( StructDecl * decl );
    6262
    6363                void handle( StructDecl * );
    … …  
    6767
    6868                virtual bool is_target( StructDecl * decl ) = 0;
     69
     70                Expression * postmutate( KeywordCastExpr * cast );
    6971
    7072          private:
    … …  
    7476                const std::string context_error;
    7577                bool needs_main;
     78                KeywordCastExpr::Target cast_target;
    7679
    7780                StructDecl* type_decl = nullptr;
    … …  
    9699                        "get_thread",
    97100                        "thread keyword requires threads to be in scope, add #include <thread>",
    98                         true
     101                        true,
     102                        KeywordCastExpr::Thread
    99103                )
    100104                {}
    … …  
    106110                static void implement( std::list< Declaration * > & translationUnit ) {
    107111                        PassVisitor< ThreadKeyword > impl;
    108                         acceptAll( translationUnit, impl );
     112                        mutateAll( translationUnit, impl );
    109113                }
    110114        };
    … …  
    127131                        "get_coroutine",
    128132                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
    129                         true
     133                        true,
     134                        KeywordCastExpr::Coroutine
    130135                )
    131136                {}
    … …  
    137142                static void implement( std::list< Declaration * > & translationUnit ) {
    138143                        PassVisitor< CoroutineKeyword > impl;
    139                         acceptAll( translationUnit, impl );
     144                        mutateAll( translationUnit, impl );
    140145                }
    141146        };
    … …  
    158163                        "get_monitor",
    159164                        "monitor keyword requires monitors to be in scope, add #include <monitor>",
    160                         false
     165                        false,
     166                        KeywordCastExpr::Monitor
    161167                )
    162168                {}
    … …  
    168174                static void implement( std::list< Declaration * > & translationUnit ) {
    169175                        PassVisitor< MonitorKeyword > impl;
    170                         acceptAll( translationUnit, impl );
     176                        mutateAll( translationUnit, impl );
    171177                }
    172178        };
    … …  
    263269        }
    264270
    265         void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
     271        Declaration * ConcurrentSueKeyword::postmutate(StructDecl * decl) {
    266272                if( decl->name == type_name && decl->body ) {
    267273                        assert( !type_decl );
    … …  
    271277                        handle( decl );
    272278                }
    273         }
     279                return decl;
     280        }
     281
     282        Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
     283                if ( cast_target == cast->target ) {
     284                        // convert (thread &)t to (thread_desc &)*get_thread(t), etc.
     285                        if( !type_decl ) SemanticError( cast, context_error );
     286                        Expression * arg = cast->arg;
     287                        cast->arg = nullptr;
     288                        delete cast;
     289                        return new CastExpr(
     290                                UntypedExpr::createDeref(
     291                                        new UntypedExpr( new NameExpr( getter_name ), { arg } )
     292                                ),
     293                                new ReferenceType(
     294                                        noQualifiers,
     295                                        new StructInstType( noQualifiers, type_decl ) )
     296                                );
     297                }
     298                return cast;
     299        }
     300
    274301
    275302        void ConcurrentSueKeyword::handle( StructDecl * decl ) {

  • src/ControlStruct/ExceptTranslate.cc

    r2efe4b8 r1cdfa82  
    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
    … …  
    311311                        // Update variables in the body to point to this local copy.
    312312                        {
    313                                 VarExprReplacer::DeclMap mapping;
     313                                DeclReplacer::DeclMap mapping;
    314314                                mapping[ handler_decl ] = local_except;
    315                                 VarExprReplacer::replace( handler->body, mapping );
     315                                DeclReplacer::replace( handler->body, mapping );
    316316                        }
    317317

  • src/ControlStruct/MLEMutator.cc

    r2efe4b8 r1cdfa82  
    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:
    … …  
    186261                Label contLabel = generator->newLabel("loopContinue", loopStmt);
    187262                enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
     263                GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
    188264        }
    189265
    … …  
    196272
    197273                // this will take the necessary steps to add definitions of the previous two labels, if they are used.
    198                 loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
    199                 enclosingControlStructures.pop_back();
     274                loopStmt->body = mutateLoop( loopStmt->get_body(), e );
    200275                return loopStmt;
    201276        }
    … …  
    223298                        Label brkLabel = generator->newLabel("blockBreak", ifStmt);
    224299                        enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
     300                        GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
    225301                } // if
    226302        }
    … …  
    232308                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
    233309                        } // if
    234                         enclosingControlStructures.pop_back();
    235310                } // if
    236311                return ifStmt;
    … …  
    239314        void MLEMutator::premutate( CaseStmt *caseStmt ) {
    240315                visit_children = false;
     316
     317                // mark default as seen before visiting its statements to catch default loops
     318                if ( caseStmt->isDefault() ) {
     319                        enclosingControlStructures.back().seenDefault();
     320                } // if
     321
    241322                caseStmt->condition = maybeMutate( caseStmt->condition, *visitor );
    242                 fixBlock( caseStmt->stmts );
     323                Label fallLabel = generator->newLabel( "fallThrough", caseStmt );
     324                {
     325                        // ensure that stack isn't corrupted by exceptions in fixBlock
     326                        auto guard = makeFuncGuard( [&]() { enclosingControlStructures.push_back( Entry( caseStmt, fallLabel ) ); }, [this]() { enclosingControlStructures.pop_back(); } );
     327
     328                        // empty case statement
     329                        if( ! caseStmt->stmts.empty() ) {
     330                                // the parser ensures that all statements in a case are grouped into a block
     331                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
     332                                fixBlock( block->kids, true );
     333
     334                                // add fallthrough label if necessary
     335                                assert( ! enclosingControlStructures.empty() );
     336                                if ( enclosingControlStructures.back().isFallUsed() ) {
     337                                        std::list<Label> ls{ enclosingControlStructures.back().useFallExit() };
     338                                        caseStmt->stmts.push_back( new NullStmt( ls ) );
     339                                } // if
     340                        } // if
     341                }
     342                assert( ! enclosingControlStructures.empty() );
     343                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() ) );
     344                if ( caseStmt->isDefault() ) {
     345                        if ( enclosingControlStructures.back().isFallDefaultUsed() ) {
     346                                // add fallthrough default label if necessary
     347                                std::list<Label> ls{ enclosingControlStructures.back().useFallDefaultExit() };
     348                                caseStmt->stmts.push_front( new NullStmt( ls ) );
     349                        } // if
     350                } // if
    243351        }
    244352
    … …  
    246354                // generate a label for breaking out of a labeled switch
    247355                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
    248                 enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
     356                auto it = std::find_if( switchStmt->statements.rbegin(), switchStmt->statements.rend(), [](Statement * stmt) {
     357                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     358                        return caseStmt->isDefault();
     359                });
     360                CaseStmt * defaultCase = it != switchStmt->statements.rend() ? strict_dynamic_cast<CaseStmt *>( *it ) : nullptr;
     361                Label fallDefaultLabel = defaultCase ? generator->newLabel( "fallThroughDefault", defaultCase ) : "";
     362                enclosingControlStructures.push_back( Entry(switchStmt, brkLabel, fallDefaultLabel) );
     363                GuardAction( [this]() { enclosingControlStructures.pop_back(); } );
     364
     365                // Collect valid labels for fallthrough. This is initially all labels at the same level as a case statement.
     366                // As labels are seen during traversal, they are removed, since fallthrough is not allowed to jump backwards.
     367                for ( Statement * stmt : switchStmt->statements ) {
     368                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     369                        if ( caseStmt->stmts.empty() ) continue;
     370                        CompoundStmt * block = dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
     371                        for ( Statement * stmt : block->kids ) {
     372                                for ( Label & l : stmt->labels ) {
     373                                        fallthroughLabels.insert( l );
     374                                }
     375                        }
     376                }
    249377        }
    250378
    … …  
    271399
    272400                assert ( enclosingControlStructures.back() == switchStmt );
    273                 enclosingControlStructures.pop_back();
    274401                return switchStmt;
    275402        }

  • src/ControlStruct/MLEMutator.h

    r2efe4b8 r1cdfa82  
    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/Box.cc

    r2efe4b8 r1cdfa82  
    184184                        /// change the type of generic aggregate members to char[]
    185185                        void mutateMembers( AggregateDecl * aggrDecl );
     186                        /// returns the calculated sizeof expression for ty, or nullptr for use C sizeof()
     187                        Expression* genSizeof( Type* ty );
    186188
    187189                        /// Enters a new scope for type-variables, adding the type variables from ty
    … …  
    383385                unsigned long n_members = 0;
    384386                bool firstMember = true;
    385                 for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) {
    386                         DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
     387                for ( Declaration* member : structDecl->get_members() ) {
     388                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
    387389                        assert( dwt );
    388390                        Type *memberType = dwt->get_type();
    … …  
    17371739                }
    17381740
     1741                Expression * PolyGenericCalculator::genSizeof( Type* ty ) {
     1742                        if ( ArrayType * aty = dynamic_cast<ArrayType *>(ty) ) {
     1743                                // generate calculated size for possibly generic array
     1744                                Expression * sizeofBase = genSizeof( aty->get_base() );
     1745                                if ( ! sizeofBase ) return nullptr;
     1746                                Expression * dim = aty->get_dimension();
     1747                                aty->set_dimension( nullptr );
     1748                                return makeOp( "?*?", sizeofBase, dim );
     1749                        } else if ( findGeneric( ty ) ) {
     1750                                // generate calculated size for generic type
     1751                                return new NameExpr( sizeofName( mangleType( ty ) ) );
     1752                        } else return nullptr;
     1753                }
     1754
    17391755                Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
    1740                         Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
    1741                         if ( findGeneric( ty ) ) {
    1742                                 return new NameExpr( sizeofName( mangleType( ty ) ) );
    1743                         }
    1744                         return sizeofExpr;
     1756                        Type *ty = sizeofExpr->get_isType() ?
     1757                                sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
     1758                       
     1759                        Expression * gen = genSizeof( ty );
     1760                        return gen ? gen : sizeofExpr;
    17451761                }
    17461762

  • src/GenPoly/GenPoly.cc

    r2efe4b8 r1cdfa82  
    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/InstantiateGeneric.cc

    r2efe4b8 r1cdfa82  
    484484        Expression * FixDtypeStatic::fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr ) {
    485485                // need to cast dtype-static member expressions to their actual type before that type is erased.
     486                // NOTE: the casts here have the third argument (isGenerated) set to false so that these casts persist until Box, where they are needed.
    486487                auto & baseParams = *inst->get_baseParameters();
    487488                if ( isDtypeStatic( baseParams ) ) {
    … …  
    503504                                        // Note: this currently creates more temporaries than is strictly necessary, since it does not check for duplicate uses of the same member expression.
    504505                                        static UniqueName tmpNamer( "_dtype_static_member_" );
    505                                         Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ) );
     506                                        Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ), false );
    506507                                        ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), new ReferenceType( Type::Qualifiers(), concType ), new SingleInit( init ) );
    507508                                        stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
    … …  
    509510                                } else {
    510511                                        // can simply add a cast to actual type
    511                                         return new CastExpr( memberExpr, concType );
     512                                        return new CastExpr( memberExpr, concType, false );
    512513                                }
    513514                        }

  • src/GenPoly/Lvalue.cc

    r2efe4b8 r1cdfa82  
    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 );
    … …  
    5859                }
    5960
    60                 struct ReferenceConversions final {
     61                struct ReferenceConversions final : public WithStmtsToAdd {
    6162                        Expression * postmutate( CastExpr * castExpr );
    6263                        Expression * postmutate( AddressExpr * addrExpr );
    … …  
    9697                };
    9798
    98                 struct AddrRef final : public WithGuards {
     99                struct AddrRef final : public WithGuards, public WithVisitorRef<AddrRef>, public WithShortCircuiting {
    99100                        void premutate( AddressExpr * addrExpr );
    100101                        Expression * postmutate( AddressExpr * addrExpr );
    101102                        void premutate( Expression * expr );
     103                        void premutate( ApplicationExpr * appExpr );
     104                        void premutate( SingleInit * init );
     105
     106                        void handleNonAddr( Expression * );
    102107
    103108                        bool first = true;
    104109                        bool current = false;
    105110                        int refDepth = 0;
     111                        bool addCast = false;
    106112                };
    107113        } // namespace
    … …  
    113119        }
    114120
    115         void convertLvalue( std::list< Declaration* >& translationUnit ) {
     121        void convertLvalue( std::list< Declaration* > & translationUnit ) {
    116122                PassVisitor<ReferenceConversions> refCvt;
    117123                PassVisitor<ReferenceTypeElimination> elim;
    … …  
    149155                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
    150156                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
    151                                         Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
    152                                         return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
     157                                        Type * ret = ftype->returnVals.empty() ? nullptr : ftype->returnVals.front()->get_type();
     158                                        return func->linkage == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
    153159                                }
    154160                        }
    … …  
    159165                        if ( isIntrinsicReference( appExpr ) ) {
    160166                                // eliminate reference types from intrinsic applications - now they return lvalues
    161                                 Type * result = appExpr->get_result();
    162                                 appExpr->set_result( result->stripReferences()->clone() );
    163                                 appExpr->get_result()->set_lvalue( true );
     167                                Type * result = appExpr->result;
     168                                appExpr->result = result->stripReferences()->clone();
     169                                appExpr->result->set_lvalue( true );
    164170                                if ( ! inIntrinsic ) {
    165171                                        // when not in an intrinsic function, add a cast to
    166172                                        // don't add cast when in an intrinsic function, since they already have the cast
    167173                                        Expression * ret = new CastExpr( appExpr, result );
    168                                         ret->set_env( appExpr->get_env() );
    169                                         appExpr->set_env( nullptr );
     174                                        std::swap( ret->env, appExpr->env );
    170175                                        return ret;
    171176                                }
    … …  
    185190                                assertf( ftype, "Function declaration does not have function type." );
    186191                                // can be of differing lengths only when function is variadic
    187                                 assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
     192                                assertf( ftype->parameters.size() == appExpr->args.size() || ftype->isVarArgs, "ApplicationExpr args do not match formal parameter type." );
    188193
    189194
    190195                                unsigned int i = 0;
    191                                 const unsigned int end = ftype->get_parameters().size();
    192                                 for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
     196                                const unsigned int end = ftype->parameters.size();
     197                                for ( auto p : unsafe_group_iterate( appExpr->args, ftype->parameters ) ) {
    193198                                        if (i == end) break;
    194199                                        Expression *& arg = std::get<0>( p );
    … …  
    196201                                        PRINT(
    197202                                                std::cerr << "pair<0>: " << arg << std::endl;
     203                                                std::cerr << " -- " << arg->result << std::endl;
    198204                                                std::cerr << "pair<1>: " << formal << std::endl;
    199205                                        )
    200206                                        if ( dynamic_cast<ReferenceType*>( formal ) ) {
    201                                                 if ( isIntrinsicReference( arg ) ) { // do not combine conditions, because that changes the meaning of the else if
    202                                                         if ( function->get_linkage() != LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references
    203                                                                 // if argument is dereference or array subscript, the result isn't REALLY a reference, so it's not necessary to fix the argument
    204                                                                 PRINT(
    205                                                                         std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
    206                                                                 )
    207                                                                 arg = new AddressExpr( arg );
    208                                                         }
    209                                                 } else if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
    210                                                         // std::cerr << "===adding deref to arg" << std::endl;
    211                                                         // if the parameter is a reference, add a dereference to the reference-typed argument.
    212                                                         Type * baseType = InitTweak::getPointerBase( arg->get_result() );
    213                                                         assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
    214                                                         arg->set_result( new PointerType{ Type::Qualifiers(), baseType->clone() } );
     207                                                PRINT(
     208                                                        std::cerr << "===formal is reference" << std::endl;
     209                                                )
     210                                                // TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
     211
     212                                                if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
     213                                                        // needed for definition of prelude functions, etc.
     214                                                        // if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
     215
     216                                                        // NOTE: previously, this condition fixed
     217                                                        //   void f(int *&);
     218                                                        //   int & x = ...;
     219                                                        //   f(&x);
     220                                                        // But now this is taken care of by a reference cast added by AddrRef. Need to find a new
     221                                                        // example or remove this branch.
     222
     223                                                        PRINT(
     224                                                                std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
     225                                                        )
     226                                                        arg = new AddressExpr( arg );
     227                                                // } else if ( function->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getPointerBase( arg->result ) ) {
     228                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
     229                                                        // argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
     230                                                        PRINT(
     231                                                                std::cerr << "===is non-intrinsic arg in intrinsic call - adding deref to arg" << std::endl;
     232                                                        )
     233                                                        Type * baseType = InitTweak::getPointerBase( arg->result );
     234                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->result ).c_str() );
     235                                                        arg->set_result( new PointerType( Type::Qualifiers(), baseType->clone() ) );
    215236                                                        arg = mkDeref( arg );
     237                                                        // assertf( arg->result->referenceDepth() == 0, "Reference types should have been eliminated from intrinsic function calls, but weren't: %s", toCString( arg->result ) );
    216238                                                }
    217239                                        }
    … …  
    223245
    224246                // idea: &&&E: get outer &, inner &
    225                 // at inner &, record depth D of reference type
     247                // at inner &, record depth D of reference type of argument of &
    226248                // at outer &, add D derefs.
    227                 void AddrRef::premutate( Expression * ) {
     249                void AddrRef::handleNonAddr( Expression * ) {
     250                        // non-address-of: reset status variables:
     251                        // * current expr is NOT the first address-of expr in an address-of chain
     252                        // * next seen address-of expr IS the first in the chain.
    228253                        GuardValue( current );
    229254                        GuardValue( first );
    … …  
    232257                }
    233258
     259                void AddrRef::premutate( Expression * expr ) {
     260                        handleNonAddr( expr );
     261                        GuardValue( addCast );
     262                        addCast = false;
     263                }
     264
    234265                void AddrRef::premutate( AddressExpr * ) {
    235266                        GuardValue( current );
    236267                        GuardValue( first );
    237                         current = first;
    238                         first = false;
    239                         if ( current ) {
     268                        current = first; // is this the first address-of in the chain?
     269                        first = false;   // from here out, no longer possible for next address-of to be first in chain
     270                        if ( current ) { // this is the outermost address-of in a chain
    240271                                GuardValue( refDepth );
    241                                 refDepth = 0;
     272                                refDepth = 0;  // set depth to 0 so that postmutate can find the innermost address-of easily
    242273                        }
    243274                }
    244275
    245276                Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
     277                        PRINT( std::cerr << "addr ref at " << addrExpr << std::endl; )
    246278                        if ( refDepth == 0 ) {
    247                                 if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) {
     279                                PRINT( std::cerr << "depth 0, get new depth..." << std::endl; )
     280                                // this is the innermost address-of in a chain, record depth D
     281                                if ( ! isIntrinsicReference( addrExpr->arg ) ) {
    248282                                        // try to avoid ?[?]
    249                                         refDepth = addrExpr->get_arg()->get_result()->referenceDepth();
    250                                 }
    251                         }
    252                         if ( current ) {
     283                                        // xxx - is this condition still necessary? intrinsicReferences should have a cast around them at this point, so I don't think this condition ever fires.
     284                                        refDepth = addrExpr->arg->result->referenceDepth();
     285                                        PRINT( std::cerr << "arg not intrinsic reference, new depth is: " << refDepth << std::endl; )
     286                                } else {
     287                                        assertf( false, "AddrRef : address-of should not have intrinsic reference argument: %s", toCString( addrExpr->arg ) );
     288                                }
     289                        }
     290                        if ( current ) { // this is the outermost address-of in a chain
     291                                PRINT( std::cerr << "current, depth is: " << refDepth << std::endl; )
    253292                                Expression * ret = addrExpr;
    254293                                while ( refDepth ) {
     294                                        // add one dereference for each
    255295                                        ret = mkDeref( ret );
    256296                                        refDepth--;
    257297                                }
     298
     299                                // if addrExpr depth is 0, then the result is a pointer because the arg was depth 1 and not lvalue.
     300                                // This means the dereference result is not a reference, is lvalue, and one less pointer depth than
     301                                // the addrExpr. Thus the cast is meaningless.
     302                                // TODO: One thing to double check is whether it is possible for the types to differ outside of the single
     303                                // pointer level (i.e. can the base type of addrExpr differ from the type of addrExpr-arg?).
     304                                // If so then the cast might need to be added, conditional on a more sophisticated check.
     305                                if ( addCast && addrExpr->result->referenceDepth() != 0 ) {
     306                                        PRINT( std::cerr << "adding cast to " << addrExpr->result << std::endl; )
     307                                        return new CastExpr( ret, addrExpr->result->clone() );
     308                                }
    258309                                return ret;
    259310                        }
     311                        PRINT( std::cerr << "not current..." << std::endl; )
    260312                        return addrExpr;
    261313                }
     314
     315                void AddrRef::premutate( ApplicationExpr * appExpr ) {
     316                        visit_children = false;
     317                        GuardValue( addCast );
     318                        handleNonAddr( appExpr );
     319                        for ( Expression *& arg : appExpr->args ) {
     320                                // each argument with address-of requires a cast
     321                                addCast = true;
     322                                arg = arg->acceptMutator( *visitor );
     323                        }
     324                }
     325
     326                void AddrRef::premutate( SingleInit * ) {
     327                        GuardValue( addCast );
     328                        // each initialization context with address-of requires a cast
     329                        addCast = true;
     330                }
     331
    262332
    263333                Expression * ReferenceConversions::postmutate( AddressExpr * addrExpr ) {
    … …  
    276346                        // pointer casts in the right places.
    277347
    278                         // conversion to reference type
    279                         if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
    280                                 (void)refType;
    281                                 if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
    282                                         // nothing to do if casting from reference to reference.
    283                                         (void)otherRef;
    284                                         PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; )
    285                                         if ( isIntrinsicReference( castExpr->get_arg() ) ) {
    286                                                 Expression * callExpr = castExpr->get_arg();
    287                                                 PRINT(
    288                                                         std::cerr << "but arg is deref -- &" << std::endl;
    289                                                         std::cerr << callExpr << std::endl;
    290                                                 )
    291                                                 callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
    292                                                 callExpr->set_result( refType->clone() );
    293                                                 // move environment out to new top-level
    294                                                 callExpr->set_env( castExpr->get_env() );
    295                                                 castExpr->set_arg( nullptr );
    296                                                 castExpr->set_env( nullptr );
    297                                                 return callExpr;
    298                                         }
    299                                         int depth1 = refType->referenceDepth();
    300                                         int depth2 = otherRef->referenceDepth();
    301                                         int diff = depth1-depth2;
    302                                         if ( diff == 0 ) {
    303                                                 // conversion between references of the same depth
    304                                                 assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
    305                                                 PRINT( std::cerr << castExpr << std::endl; )
    306                                                 return castExpr;
    307                                         } else if ( diff < 0 ) {
    308                                                 // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
    309                                                 Expression * ret = castExpr->arg;
    310                                                 for ( int i = 0; i < diff; ++i ) {
    311                                                         ret = mkDeref( ret );
    312                                                 }
    313                                                 ret->env = castExpr->env;
    314                                                 ret->result = castExpr->result;
    315                                                 ret->result->set_lvalue( true ); // ensure result is lvalue
    316                                                 castExpr->env = nullptr;
    317                                                 castExpr->arg = nullptr;
    318                                                 castExpr->result = nullptr;
    319                                                 return ret;
    320                                         } else if ( diff > 0 ) {
    321                                                 // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
    322                                                 Expression * ret = castExpr->arg;
    323                                                 for ( int i = 0; i < diff; ++i ) {
    324                                                         ret = new AddressExpr( ret );
    325                                                 }
    326                                                 ret->env = castExpr->env;
    327                                                 ret->result = castExpr->result;
    328                                                 castExpr->env = nullptr;
    329                                                 castExpr->arg = nullptr;
    330                                                 castExpr->result = nullptr;
    331                                                 return ret;
    332                                         }
    333 
    334                                         assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
    335                                         PRINT( std::cerr << castExpr << std::endl; )
     348                        // Note: reference depth difference is the determining factor in what code is run, rather than whether something is
     349                        // reference type or not, since conversion still needs to occur when both types are references that differ in depth.
     350
     351                        Type * destType = castExpr->result;
     352                        Type * srcType = castExpr->arg->result;
     353                        int depth1 = destType->referenceDepth();
     354                        int depth2 = srcType->referenceDepth();
     355                        int diff = depth1 - depth2;
     356
     357                        if ( diff > 0 && ! srcType->get_lvalue() ) {
     358                                // rvalue to reference conversion -- introduce temporary
     359                                // know that reference depth of cast argument is 0, need to introduce n temporaries for reference depth of n, e.g.
     360                                //   (int &&&)3;
     361                                // becomes
     362                                //   int __ref_tmp_0 = 3;
     363                                //   int & __ref_tmp_1 = _&_ref_tmp_0;
     364                                //   int && __ref_tmp_2 = &__ref_tmp_1;
     365                                //   &__ref_tmp_2;
     366                                // the last & comes from the remaining reference conversion code
     367                                SemanticWarning( castExpr->arg->location, Warning::RvalueToReferenceConversion, toCString( castExpr->arg ) );
     368
     369                                static UniqueName tempNamer( "__ref_tmp_" );
     370                                ObjectDecl * temp = ObjectDecl::newObject( tempNamer.newName(), castExpr->arg->result->clone(), new SingleInit( castExpr->arg ) );
     371                                PRINT( std::cerr << "made temp: " << temp << std::endl; )
     372                                stmtsToAddBefore.push_back( new DeclStmt( temp ) );
     373                                for ( int i = 0; i < depth1-1; i++ ) { // xxx - maybe this should be diff-1? check how this works with reference type for srcType
     374                                        ObjectDecl * newTemp = ObjectDecl::newObject( tempNamer.newName(), new ReferenceType( Type::Qualifiers(), temp->type->clone() ), new SingleInit( new AddressExpr( new VariableExpr( temp ) ) ) );
     375                                        PRINT( std::cerr << "made temp" << i << ": " << newTemp << std::endl; )
     376                                        stmtsToAddBefore.push_back( new DeclStmt( newTemp ) );
     377                                        temp = newTemp;
     378                                }
     379                                // update diff so that remaining code works out correctly
     380                                castExpr->arg = new VariableExpr( temp );
     381                                PRINT( std::cerr << "update cast to: " << castExpr << std::endl; )
     382                                srcType = castExpr->arg->result;
     383                                depth2 = srcType->referenceDepth();
     384                                diff = depth1 - depth2;
     385                                assert( diff == 1 );
     386                        }
     387
     388                        // handle conversion between different depths
     389                        PRINT (
     390                                if ( depth1 || depth2 ) {
     391                                        std::cerr << "destType: " << destType << " / srcType: " << srcType << std::endl;
     392                                        std::cerr << "depth: " << depth1 << " / " << depth2 << std::endl;
     393                                }
     394                        )
     395                        if ( diff > 0 ) {
     396                                // conversion to type with more depth (e.g. int & -> int &&): add address-of for each level of difference
     397                                Expression * ret = castExpr->arg;
     398                                for ( int i = 0; i < diff; ++i ) {
     399                                        ret = new AddressExpr( ret );
     400                                }
     401                                if ( srcType->get_lvalue() && srcType->get_qualifiers() != strict_dynamic_cast<ReferenceType *>( destType )->base->get_qualifiers() ) {
     402                                        // must keep cast if cast-to type is different from the actual type
     403                                        castExpr->arg = ret;
    336404                                        return castExpr;
    337                                 } else if ( castExpr->arg->result->get_lvalue() ) {
    338                                         // conversion from lvalue to reference
    339                                         // xxx - keep cast, but turn into pointer cast??
    340                                         // xxx - memory
    341                                         PRINT(
    342                                                 std::cerr << "convert lvalue to reference -- &" << std::endl;
    343                                                 std::cerr << castExpr->arg << std::endl;
    344                                         )
    345                                         AddressExpr * ret = new AddressExpr( castExpr->arg );
    346                                         if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
    347                                                 // must keep cast if cast-to type is different from the actual type
    348                                                 castExpr->arg = ret;
    349                                                 return castExpr;
    350                                         }
    351                                         ret->env = castExpr->env;
    352                                         ret->result = castExpr->result;
    353                                         castExpr->env = nullptr;
    354                                         castExpr->arg = nullptr;
    355                                         castExpr->result = nullptr;
    356                                         return ret;
    357                                 } else {
    358                                         // rvalue to reference conversion -- introduce temporary
    359                                 }
    360                                 assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
    361                         } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
    362                                 (void)refType;
    363                                 // conversion from reference to rvalue
    364                                 PRINT(
    365                                         std::cerr << "convert reference to rvalue -- *" << std::endl;
    366                                         std::cerr << "was = " << castExpr << std::endl;
    367                                 )
     405                                }
     406                                ret->env = castExpr->env;
     407                                ret->result = castExpr->result;
     408                                castExpr->env = nullptr;
     409                                castExpr->arg = nullptr;
     410                                castExpr->result = nullptr;
     411                                return ret;
     412                        } else if ( diff < 0 ) {
     413                                // conversion to type with less depth (e.g. int && -> int &): add dereferences for each level of difference
     414                                diff = -diff; // care only about magnitude now
    368415                                Expression * ret = castExpr->arg;
    369                                 TypeSubstitution * env = castExpr->env;
    370                                 castExpr->set_env( nullptr );
    371                                 if ( ! isIntrinsicReference( ret ) ) {
    372                                         // dereference if not already dereferenced
     416                                for ( int i = 0; i < diff; ++i ) {
    373417                                        ret = mkDeref( ret );
    374                                 }
    375                                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
    376                                         // can remove cast if types are compatible, changing expression type to value type
    377                                         ret->result = castExpr->result->clone();
    378                                         ret->result->set_lvalue( true );  // ensure result is lvalue
    379                                         castExpr->arg = nullptr;
    380                                 } else {
     418                                        // xxx - try removing one reference here? actually, looks like mkDeref already does this, so more closely look at the types generated.
     419                                }
     420                                if ( ! ResolvExpr::typesCompatibleIgnoreQualifiers( destType->stripReferences(), srcType->stripReferences(), SymTab::Indexer() ) ) {
    381421                                        // must keep cast if types are different
    382422                                        castExpr->arg = ret;
    383                                         ret = castExpr;
    384                                 }
    385                                 ret->set_env( env );
    386                                 PRINT( std::cerr << "now: " << ret << std::endl; )
     423                                        return castExpr;
     424                                }
     425                                ret->env = castExpr->env;
     426                                ret->result = castExpr->result;
     427                                ret->result->set_lvalue( true ); // ensure result is lvalue
     428                                castExpr->env = nullptr;
     429                                castExpr->arg = nullptr;
     430                                castExpr->result = nullptr;
    387431                                return ret;
    388                         }
    389                         return castExpr;
     432                        } else {
     433                                assert( diff == 0 );
     434                                // conversion between references of the same depth
     435                                if ( ResolvExpr::typesCompatible( castExpr->result, castExpr->arg->result, SymTab::Indexer() ) && castExpr->isGenerated ) {
     436                                        // Remove useless generated casts
     437                                        PRINT(
     438                                                std::cerr << "types are compatible, removing cast: " << castExpr << std::endl;
     439                                                std::cerr << "-- " << castExpr->result << std::endl;
     440                                                std::cerr << "-- " << castExpr->arg->result << std::endl;
     441                                        )
     442                                        Expression * ret = castExpr->arg;
     443                                        castExpr->arg = nullptr;
     444                                        std::swap( castExpr->env, ret->env );
     445                                        return ret;
     446                                }
     447                                return castExpr;
     448                        }
    390449                }
    391450
    392451                Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
    393                         Type * base = refType->get_base();
     452                        Type * base = refType->base;
    394453                        Type::Qualifiers qualifiers = refType->get_qualifiers();
    395                         refType->set_base( nullptr );
     454                        refType->base = nullptr;
    396455                        return new PointerType( qualifiers, base );
    397456                }
    … …  
    400459                Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
    401460                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
    402                                 Expression * arg1 = commaExpr->get_arg1()->clone();
    403                                 Expression * arg2 = commaExpr->get_arg2()->clone();
     461                                Expression * arg1 = commaExpr->arg1->clone();
     462                                Expression * arg2 = commaExpr->arg2->clone();
    404463                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
    405                                 ret->set_env( expr->get_env() );
    406                                 expr->set_env( nullptr );
     464                                ret->env = expr->env;
     465                                expr->env = nullptr;
    407466                                return ret;
    408467                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
    409                                 Expression * arg1 = condExpr->get_arg1()->clone();
    410                                 Expression * arg2 = condExpr->get_arg2()->clone();
    411                                 Expression * arg3 = condExpr->get_arg3()->clone();
     468                                Expression * arg1 = condExpr->arg1->clone();
     469                                Expression * arg2 = condExpr->arg2->clone();
     470                                Expression * arg3 = condExpr->arg3->clone();
    412471                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
    413                                 ret->set_env( expr->get_env() );
    414                                 expr->set_env( nullptr );
     472                                ret->env = expr->env;
     473                                expr->env = nullptr;
    415474
    416475                                // conditional expr type may not be either of the argument types, need to unify
    … …  
    420479                                AssertionSet needAssertions, haveAssertions;
    421480                                OpenVarSet openVars;
    422                                 unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
    423                                 ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
     481                                unify( ret->arg2->result, ret->arg3->result, newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
     482                                ret->result = commonType ? commonType : ret->arg2->result->clone();
    424483                                return ret;
    425484                        }
    … …  
    428487
    429488                Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
    430                         return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
     489                        return applyTransformation( memExpr, memExpr->aggregate, [=]( Expression * aggr ) { return new MemberExpr( memExpr->member, aggr ); } );
    431490                }
    432491
    433492                Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
    434                         return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
     493                        return applyTransformation( addrExpr, addrExpr->arg, []( Expression * arg ) { return new AddressExpr( arg ); } );
    435494                }
    436495
    437496                Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) {
    438                         Expression * arg = addrExpr->get_arg();
     497                        Expression * arg = addrExpr->arg;
    439498                        if ( isIntrinsicReference( arg ) ) {
    440499                                std::string fname = InitTweak::getFunctionName( arg );
    … …  
    442501                                        Expression *& arg0 = InitTweak::getCallArg( arg, 0 );
    443502                                        Expression * ret = arg0;
    444                                         ret->set_env( addrExpr->get_env() );
     503                                        ret->set_env( addrExpr->env );
    445504                                        arg0 = nullptr;
    446                                         addrExpr->set_env( nullptr );
     505                                        addrExpr->env = nullptr;
    447506                                        return ret;
    448507                                }
    … …  
    470529                                        // }
    471530                                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) {
    472                                                 Expression * ret = addrExpr->get_arg();
    473                                                 ret->set_env( appExpr->get_env() );
    474                                                 addrExpr->set_arg( nullptr );
    475                                                 appExpr->set_env( nullptr );
     531                                                Expression * ret = addrExpr->arg;
     532                                                ret->env = appExpr->env;
     533                                                addrExpr->arg = nullptr;
     534                                                appExpr->env = nullptr;
    476535                                                return ret;
    477536                                        }

  • src/InitTweak/InitTweak.cc

    r2efe4b8 r1cdfa82  
    529529                }
    530530                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
    531                         dst = new AddressExpr( dst );
     531                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
     532                                dst = new AddressExpr( dst );
     533                        }
    532534                } else {
    533535                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
    534536                }
    535537                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
    536                         src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
     538                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
     539                                src = new AddressExpr( src );
     540                        }
     541                        // src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
    537542                }
    538543                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );

  • src/Makefile.in

    r2efe4b8 r1cdfa82  
    251251        SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
    252252        SynTree/driver_cfa_cpp-BaseSyntaxNode.$(OBJEXT) \
    253         SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
     253        SynTree/driver_cfa_cpp-DeclReplacer.$(OBJEXT) \
    254254        Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
    255255        Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT) \
    … …  
    529529        SynTree/Initializer.cc SynTree/TypeSubstitution.cc \
    530530        SynTree/Attribute.cc SynTree/BaseSyntaxNode.cc \
    531         SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
     531        SynTree/DeclReplacer.cc Tuples/TupleAssignment.cc \
    532532        Tuples/TupleExpansion.cc Tuples/Explode.cc \
    533533        Virtual/ExpandCasts.cc
    … …  
    919919SynTree/driver_cfa_cpp-BaseSyntaxNode.$(OBJEXT):  \
    920920        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
    921 SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
     921SynTree/driver_cfa_cpp-DeclReplacer.$(OBJEXT):  \
    922922        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
    923923Tuples/$(am__dirstamp):
    … …  
    10481048@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-CompoundStmt.Po@am__quote@
    10491049@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Constant.Po@am__quote@
     1050@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Po@am__quote@
    10501051@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-DeclStmt.Po@am__quote@
    10511052@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Declaration.Po@am__quote@
    … …  
    10691070@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeofType.Po@am__quote@
    10701071@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po@am__quote@
    1071 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po@am__quote@
    10721072@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
    10731073@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
    … …  
    25352535@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-BaseSyntaxNode.obj `if test -f 'SynTree/BaseSyntaxNode.cc'; then $(CYGPATH_W) 'SynTree/BaseSyntaxNode.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/BaseSyntaxNode.cc'; fi`
    25362536
    2537 SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
    2538 @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
    2539 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
    2540 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.o' libtool=no @AMDEPBACKSLASH@
    2541 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2542 @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
    2543 
    2544 SynTree/driver_cfa_cpp-VarExprReplacer.obj: SynTree/VarExprReplacer.cc
    2545 @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`
    2546 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
    2547 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.obj' libtool=no @AMDEPBACKSLASH@
    2548 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2549 @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`
     2537SynTree/driver_cfa_cpp-DeclReplacer.o: SynTree/DeclReplacer.cc
     2538@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
     2539@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Po
     2540@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/DeclReplacer.cc' object='SynTree/driver_cfa_cpp-DeclReplacer.o' libtool=no @AMDEPBACKSLASH@
     2541@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2542@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
     2543
     2544SynTree/driver_cfa_cpp-DeclReplacer.obj: SynTree/DeclReplacer.cc
     2545@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`
     2546@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-DeclReplacer.Po
     2547@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/DeclReplacer.cc' object='SynTree/driver_cfa_cpp-DeclReplacer.obj' libtool=no @AMDEPBACKSLASH@
     2548@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2549@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`
    25502550
    25512551Tuples/driver_cfa_cpp-TupleAssignment.o: Tuples/TupleAssignment.cc

  • src/Parser/DeclarationNode.cc

    r2efe4b8 r1cdfa82  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 15:37:17 2018
    13 // Update Count     : 1033
     12// Last Modified On : Fri Apr 20 22:37:20 2018
     13// Update Count     : 1063
    1414//
    1515
    … …  
    4747const char * DeclarationNode::aggregateNames[] = { "struct", "union", "trait", "coroutine", "monitor", "thread", "NoAggregateNames" };
    4848const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
    49 const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };
     49const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "zero_t", "one_t", "NoBuiltinTypeNames" };
    5050
    5151UniqueName DeclarationNode::anonymous( "__anonymous" );
    … …  
    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 ) {
    … …  
    544561
    545562        checkQualifiers( type, q->type );
     563        if ( (builtin == Zero || builtin == One) && error.length() == 0 ) {
     564                SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, Type::QualifiersNames[ilog2( q->type->qualifiers.val )], builtinTypeNames[builtin] );
     565//              appendError( error, string( "questionable qualifiers" ) );
     566        } // if
    546567        addQualifiersToType( q->type, type );
    547568
    … …  
    907928                                delete newType->aggInst.aggregate->enumeration.constants;
    908929                                newType->aggInst.aggregate->enumeration.constants = nullptr;
     930                                newType->aggInst.aggregate->enumeration.body = false;
    909931                        } else {
    910932                                assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
    911933                                delete newType->aggInst.aggregate->aggregate.fields;
    912934                                newType->aggInst.aggregate->aggregate.fields = nullptr;
     935                                newType->aggInst.aggregate->aggregate.body = false;
    913936                        } // if
    914937                        // don't hoist twice
    … …  
    10511074        } // if
    10521075
     1076        if ( assert.condition ) {
     1077                return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
     1078        }
     1079
    10531080        // SUE's cannot have function specifiers, either
    10541081        //

  • src/Parser/ExpressionNode.cc

    r2efe4b8 r1cdfa82  
    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
    … …  
    222211        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
    223212                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
    224                 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
     213                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
    225214        } else if ( lnth != -1 ) {                                                      // explicit length ?
    226215                if ( lnth == 5 ) {                                                              // int128 ?
    227216                        size = 5;
    228                         ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
     217                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ), false );
    229218                } else {
    230                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
     219                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ), false );
    231220                } // if
    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
    … …  
    302285        Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
    303286        if ( lnth != -1 ) {                                                                     // explicit length ?
    304                 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 } );
     287                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ), false );
    308288        } // if
    309289
    … …  
    427407        Type * targetType = maybeMoveBuildType( decl_node );
    428408        if ( dynamic_cast< VoidType * >( targetType ) ) {
    429                 return new CastExpr( maybeMoveBuild< Expression >(expr_node) );
     409                return new CastExpr( maybeMoveBuild< Expression >(expr_node), false );
    430410        } else {
    431                 return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType );
     411                return new CastExpr( maybeMoveBuild< Expression >(expr_node), targetType, false );
    432412        } // if
    433413} // build_cast
     414
     415Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node ) {
     416        return new KeywordCastExpr( maybeMoveBuild< Expression >(expr_node), target );
     417}
    434418
    435419Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node ) {

  • src/Parser/ParseNode.h

    r2efe4b8 r1cdfa82  
    179179
    180180Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
     181Expression * build_keyword_cast( KeywordCastExpr::Target target, ExpressionNode * expr_node );
    181182Expression * build_virtual_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
    182183Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
    … …  
    246247        static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
    247248        static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
     249        static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
    248250
    249251        DeclarationNode();
    … …  
    313315        Attr_t attr;
    314316
     317        struct StaticAssert_t {
     318                ExpressionNode * condition;
     319                Expression * message;
     320        };
     321        StaticAssert_t assert;
     322
    315323        BuiltinType builtin;
    316324
    … …  
    392400
    393401Statement * build_if( IfCtl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
    394 Statement * build_switch( ExpressionNode * ctl, StatementNode * stmt );
     402Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
    395403Statement * build_case( ExpressionNode * ctl );
    396404Statement * build_default();

  • src/Parser/StatementNode.cc

    r2efe4b8 r1cdfa82  
    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
    … …  
    115115}
    116116
    117 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
     117Statement *build_switch( bool isSwitch, ExpressionNode *ctl, StatementNode *stmt ) {
    118118        std::list< Statement * > branches;
    119119        buildMoveList< Statement, StatementNode >( stmt, branches );
     120        if ( ! isSwitch ) {                                                                             // choose statement
     121                for ( Statement * stmt : branches ) {
     122                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
     123                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
     124                                CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() );
     125                                block->kids.push_back( new BranchStmt( "", BranchStmt::Break ) );
     126                        } // if
     127                } // for
     128        } // if
    120129        // branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
    121130        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );

  • src/Parser/TypeData.cc

    r2efe4b8 r1cdfa82  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Feb 22 15:49:00 2018
    13 // Update Count     : 597
     12// Last Modified On : Tue Apr 17 23:00:52 2018
     13// Update Count     : 602
    1414//
    1515
    … …  
    395395                break;
    396396          case Builtin:
    397                 os << "gcc builtin type";
     397                os << DeclarationNode::builtinTypeNames[builtintype];
    398398                break;
    399399          default:
    … …  
    490490        switch ( td->kind ) {
    491491          case TypeData::Aggregate:
    492                 if ( ! toplevel && td->aggregate.fields ) {
     492                if ( ! toplevel && td->aggregate.body ) {
    493493                        ret = td->clone();
    494494                } // if
    495495                break;
    496496          case TypeData::Enum:
    497                 if ( ! toplevel && td->enumeration.constants ) {
     497                if ( ! toplevel && td->enumeration.body ) {
    498498                        ret = td->clone();
    499499                } // if

  • src/Parser/lex.ll

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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 : Tue Apr 17 17:10:30 2018
     13// Update Count     : 3144
    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
    … …  
    386391%precedence '('
    387392
    388 %locations                      // support location tracking for error messages
     393%locations                                                                                              // support location tracking for error messages
    389394
    390395%start translation_unit                                                                 // parse-tree root
    … …  
    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                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Coroutine, $5 ) ); }
     691        | '(' THREAD '&' ')' cast_expression                            // CFA
     692                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Thread, $5 ) ); }
     693        | '(' MONITOR '&' ')' cast_expression                           // CFA
     694                { $$ = new ExpressionNode( build_keyword_cast( KeywordCastExpr::Monitor, $5 ) ); }
    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
    … …  
    17101708        | LONG
    17111709                { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
    1712         | ZERO_T
    1713                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
    1714         | ONE_T
    1715                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
    17161710        | VALIST                                                                                        // GCC, __builtin_va_list
    17171711                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    … …  
    17331727basic_type_specifier:
    17341728        direct_type
     1729                // Cannot have type modifiers, e.g., short, long, etc.
    17351730        | type_qualifier_list_opt indirect_type type_qualifier_list_opt
    17361731                { $$ = $2->addQualifiers( $1 )->addQualifiers( $3 ); }
    … …  
    17381733
    17391734direct_type:
    1740                 // A semantic check is necessary for conflicting type qualifiers.
    17411735        basic_type_name
    17421736        | type_qualifier_list basic_type_name
    … …  
    17571751        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
    17581752                { $$ = DeclarationNode::newAttr( $1, $3 ); }
     1753        | ZERO_T                                                                                        // CFA
     1754                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
     1755        | ONE_T                                                                                         // CFA
     1756                { $$ = DeclarationNode::newBuiltinType( DeclarationNode::One ); }
    17591757        ;
    17601758
    … …  
    24132411                        $$ = $2;
    24142412                }
    2415         | forall '{' external_definition_list '}'                       // CFA, namespace
     2413        | type_qualifier_list '{' external_definition_list '}'                  // CFA, namespace
    24162414        ;
    24172415

  • src/ResolvExpr/AlternativeFinder.cc

    r2efe4b8 r1cdfa82  
    12381238        }
    12391239
    1240         Expression * restructureCast( Expression * argExpr, Type * toType ) {
     1240        Expression * restructureCast( Expression * argExpr, Type * toType, bool isGenerated ) {
    12411241                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
    12421242                        // Argument expression is a tuple and the target type is not void and not a reference type.
    … …  
    12531253                                // cast each component
    12541254                                TupleIndexExpr * idx = new TupleIndexExpr( argExpr->clone(), i );
    1255                                 componentExprs.push_back( restructureCast( idx, toType->getComponent( i ) ) );
     1255                                componentExprs.push_back( restructureCast( idx, toType->getComponent( i ), isGenerated ) );
    12561256                        }
    12571257                        assert( componentExprs.size() > 0 );
    … …  
    12601260                } else {
    12611261                        // handle normally
    1262                         return new CastExpr( argExpr, toType->clone() );
     1262                        CastExpr * ret = new CastExpr( argExpr, toType->clone() );
     1263                        ret->isGenerated = isGenerated;
     1264                        return ret;
    12631265                }
    12641266        }
    … …  
    13041306                                // count one safe conversion for each value that is thrown away
    13051307                                thisCost.incSafe( discardedValues );
    1306                                 Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
     1308                                Alternative newAlt( restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), alt.env,
    13071309                                        alt.cost, thisCost );
    13081310                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
    … …  
    17271729                                        // count one safe conversion for each value that is thrown away
    17281730                                        thisCost.incSafe( discardedValues );
    1729                                         Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
     1731                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
    17301732                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
    17311733                                }

  • src/ResolvExpr/CommonType.cc

    r2efe4b8 r1cdfa82  
    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        }
    … …  
    90101                        int diff = depth1-depth2;
    91102                        // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
    92                         if ( diff > 1 || diff < -1 ) return nullptr;
     103                        // if ( diff > 1 || diff < -1 ) return nullptr;
    93104
    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

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

  • src/ResolvExpr/Resolver.cc

    r2efe4b8 r1cdfa82  
    6060                void previsit( TypeDecl *typeDecl );
    6161                void previsit( EnumDecl * enumDecl );
     62                void previsit( StaticAssertDecl * assertDecl );
    6263
    6364                void previsit( ArrayType * at );
    … …  
    365366        }
    366367
     368        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
     369                findIntegralExpression( assertDecl->condition, indexer );
     370        }
     371
    367372        void Resolver::previsit( ExprStmt *exprStmt ) {
    368373                visit_children = false;

  • src/SymTab/Indexer.cc

    r2efe4b8 r1cdfa82  
    501501
    502502        bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) {
    503                 if ( existing->get_members().empty() ) {
     503                if ( ! existing->body ) {
    504504                        return false;
    505                 } else if ( ! added->get_members().empty() ) {
     505                } else if ( added->body ) {
    506506                        SemanticError( added, "redeclaration of " );
    507507                } // if

  • src/SymTab/Validate.cc

    r2efe4b8 r1cdfa82  
    9090                void previsit( StructDecl * aggregateDecl );
    9191                void previsit( UnionDecl * aggregateDecl );
     92                void previsit( StaticAssertDecl * assertDecl );
    9293
    9394          private:
    … …  
    148149                void previsit( ObjectDecl * object );
    149150                void previsit( FunctionDecl * func );
     151                void previsit( FunctionType * ftype );
    150152                void previsit( StructDecl * aggrDecl );
    151153                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 ); } );
     314                GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, shouldHoist, false ); } );
    313315        }
    314316
    315317        void HoistStruct::previsit( EnumInstType * inst ) {
    316                 if ( inst->baseEnum ) {
     318                if ( inst->baseEnum && inst->baseEnum->body ) {
    317319                        declsToAddBefore.push_front( inst->baseEnum );
    318320                }
    … …  
    320322
    321323        void HoistStruct::previsit( StructInstType * inst ) {
    322                 if ( inst->baseStruct ) {
     324                if ( inst->baseStruct && inst->baseStruct->body ) {
    323325                        declsToAddBefore.push_front( inst->baseStruct );
    324326                }
    … …  
    326328
    327329        void HoistStruct::previsit( UnionInstType * inst ) {
    328                 if ( inst->baseUnion ) {
     330                if ( inst->baseUnion && inst->baseUnion->body ) {
    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        }
    … …  
    623631
    624632        void ForallPointerDecay::previsit( ObjectDecl *object ) {
    625                 forallFixer( object->type->forall, object );
    626                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
    627                         forallFixer( pointer->base->forall, object );
    628                 } // if
     633                // ensure that operator names only apply to functions or function pointers
     634                if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
     635                        SemanticError( object->location, toCString( "operator ", object->name.c_str(), " is not a function or function pointer." ) );
     636                }
    629637                object->fixUniqueId();
    630638        }
    631639
    632640        void ForallPointerDecay::previsit( FunctionDecl *func ) {
    633                 forallFixer( func->type->forall, func );
    634641                func->fixUniqueId();
     642        }
     643
     644        void ForallPointerDecay::previsit( FunctionType * ftype ) {
     645                forallFixer( ftype->forall, ftype );
    635646        }
    636647
    … …  
    681692                                new_static_root<BasicType>( Type::Qualifiers(), BasicType::LongUnsignedInt );
    682693                }
    683                 filter( translationUnit, isTypedef );
     694                filter( translationUnit, isTypedef, true );
    684695        }
    685696
    … …  
    818829                        } // if
    819830                        return false;
    820                 } );
     831                }, true);
    821832                return compoundStmt;
    822833        }
    … …  
    826837        template<typename AggDecl>
    827838        AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
    828                 filter( aggDecl->members, isTypedef );
     839                filter( aggDecl->members, isTypedef, true );
    829840                return aggDecl;
    830841        }

  • src/SynTree/CompoundStmt.cc

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    7474
    7575
     76StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
     77}
     78
     79StaticAssertDecl::StaticAssertDecl( const StaticAssertDecl & other ) : Declaration( other ), condition( maybeClone( other.condition ) ), message( maybeClone( other.message ) )  {
     80}
     81
     82StaticAssertDecl::~StaticAssertDecl() {
     83        delete condition;
     84        delete message;
     85}
     86
     87void StaticAssertDecl::print( std::ostream &os, Indenter indent ) const {
     88        os << "Static Assert with condition: ";
     89        condition->print( os, indent+1 );
     90        os << std::endl << indent << "and message: ";
     91        message->print( os, indent+1 );
     92os << std::endl;
     93}
     94
     95void StaticAssertDecl::printShort( std::ostream &os, Indenter indent ) const {
     96        print( os, indent );
     97}
     98
    7699// Local Variables: //
    77100// tab-width: 4 //

  • src/SynTree/Declaration.h

    r2efe4b8 r1cdfa82  
    357357};
    358358
     359class StaticAssertDecl : public Declaration {
     360public:
     361        Expression * condition;
     362        ConstantExpr * message;   // string literal
     363
     364        StaticAssertDecl( Expression * condition, ConstantExpr * message );
     365        StaticAssertDecl( const StaticAssertDecl & other );
     366        virtual ~StaticAssertDecl();
     367
     368        virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
     369        virtual void accept( Visitor &v ) override { v.visit( this ); }
     370        virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
     371        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
     372        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
     373};
     374
    359375std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
    360376

  • src/SynTree/Expression.cc

    r2efe4b8 r1cdfa82  
    238238}
    239239
    240 CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
     240CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
    241241        set_result(toType);
    242242}
    243243
    244 CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
     244CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
    245245        set_result( new VoidType( Type::Qualifiers() ) );
    246246}
    247247
    248 CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
     248CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
    249249}
    250250
    … …  
    259259                result->print( os, indent+1 );
    260260        } // if
     261        Expression::print( os, indent );
     262}
     263
     264KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
     265}
     266
     267KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
     268}
     269
     270KeywordCastExpr::~KeywordCastExpr() {
     271        delete arg;
     272}
     273
     274const std::string & KeywordCastExpr::targetString() const {
     275        static const std::string targetStrs[] = {
     276                "coroutine", "thread", "monitor"
     277        };
     278        static_assert(
     279                (sizeof(targetStrs) / sizeof(targetStrs[0])) == ((unsigned long)NUMBER_OF_TARGETS),
     280                "Each KeywordCastExpr::Target should have a corresponding string representation"
     281        );
     282        return targetStrs[(unsigned long)target];
     283}
     284
     285void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
     286        os << "Keyword Cast of:" << std::endl << indent+1;
     287        arg->print(os, indent+1);
     288        os << std::endl << indent << "... to: ";
     289        os << targetString();
    261290        Expression::print( os, indent );
    262291}

  • src/SynTree/Expression.h

    r2efe4b8 r1cdfa82  
    184184  public:
    185185        Expression * arg;
    186 
    187         CastExpr( Expression * arg );
    188         CastExpr( Expression * arg, Type * toType );
     186        bool isGenerated = true; // whether this cast appeared in the source program
     187
     188        CastExpr( Expression * arg, bool isGenerated = true );
     189        CastExpr( Expression * arg, Type * toType, bool isGenerated = true );
     190        CastExpr( Expression * arg, void * ) = delete; // prevent accidentally passing pointers for isGenerated in the first constructor
    189191        CastExpr( const CastExpr & other );
    190192
    … …  
    193195
    194196        virtual CastExpr * clone() const { return new CastExpr( * this ); }
     197        virtual void accept( Visitor & v ) { v.visit( this ); }
     198        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
     199        virtual void print( std::ostream & os, Indenter indent = {} ) const;
     200};
     201
     202/// KeywordCastExpr represents a cast to 'keyword types', e.g. (thread &)t
     203class KeywordCastExpr : public Expression {
     204public:
     205        Expression * arg;
     206        enum Target {
     207                Coroutine, Thread, Monitor, NUMBER_OF_TARGETS
     208        } target;
     209
     210        KeywordCastExpr( Expression * arg, Target target );
     211        KeywordCastExpr( const KeywordCastExpr & other );
     212        virtual ~KeywordCastExpr();
     213
     214        const std::string & targetString() const;
     215
     216        virtual KeywordCastExpr * clone() const { return new KeywordCastExpr( * this ); }
    195217        virtual void accept( Visitor & v ) { v.visit( this ); }
    196218        virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }

  • src/SynTree/FunctionDecl.cc

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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;
    … …  
    5859        virtual Expression * mutate( UntypedExpr * untypedExpr ) = 0;
    5960        virtual Expression * mutate( NameExpr * nameExpr ) = 0;
    60         virtual Expression * mutate( AddressExpr * castExpr ) = 0;
     61        virtual Expression * mutate( AddressExpr * addrExpr ) = 0;
    6162        virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) = 0;
    6263        virtual Expression * mutate( CastExpr * castExpr ) = 0;
     64        virtual Expression * mutate( KeywordCastExpr * castExpr ) = 0;
    6365        virtual Expression * mutate( VirtualCastExpr * castExpr ) = 0;
    6466        virtual Expression * mutate( UntypedMemberExpr * memberExpr ) = 0;

  • src/SynTree/Statement.cc

    r2efe4b8 r1cdfa82  
    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 << ",";
    … …  
    188188
    189189void CaseStmt::print( std::ostream &os, Indenter indent ) const {
    190         if ( isDefault() ) os << "Default ";
     190        if ( isDefault() ) os << indent << "Default ";
    191191        else {
    192                 os << "Case ";
     192                os << indent << "Case ";
    193193                condition->print( os, indent );
    194194        } // if
    … …  
    196196
    197197        for ( Statement * stmt : stmts ) {
     198                os << indent+1;
    198199                stmt->print( os, indent+1 );
    199200        }
    … …  
    391392}
    392393
    393 void NullStmt::print( std::ostream &os, Indenter ) const {
     394void NullStmt::print( std::ostream &os, Indenter indent ) const {
    394395        os << "Null Statement" << endl;
     396        Statement::print( os, indent );
    395397}
    396398

  • src/SynTree/Statement.h

    r2efe4b8 r1cdfa82  
    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
    … …  
    246246class BranchStmt : public Statement {
    247247  public:
    248         enum Type { Goto = 0, Break, Continue };
     248        enum Type { Goto = 0, Break, Continue, FallThrough, FallThroughDefault };
    249249
    250250        // originalTarget kept for error messages.

  • src/SynTree/SynTree.h

    r2efe4b8 r1cdfa82  
    3838class TypedefDecl;
    3939class AsmDecl;
     40class StaticAssertDecl;
    4041
    4142class Statement;
    … …  
    6869class LabelAddressExpr;
    6970class CastExpr;
     71class KeywordCastExpr;
    7072class VirtualCastExpr;
    7173class MemberExpr;

  • src/SynTree/TypeSubstitution.cc

    r2efe4b8 r1cdfa82  
    132132                return inst;
    133133        } else {
    134 ///         std::cerr << "found " << inst->get_name() << ", replacing with ";
    135 ///         i->second->print( std::cerr );
    136 ///         std::cerr << std::endl;
     134                // cut off infinite loop for the case where a type is bound to itself.
     135                // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
     136                // TODO: investigate preventing type variables from being bound to themselves in the first place.
     137                if ( TypeInstType * replacement = dynamic_cast< TypeInstType * >( i->second ) ) {
     138                        if ( inst->name == replacement->name ) {
     139                                return inst;
     140                        }
     141                }
     142                // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
    137143                subCount++;
    138144                Type * newtype = i->second->clone();
    139145                newtype->get_qualifiers() |= inst->get_qualifiers();
    140                 return newtype;
     146                // 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.
     147                return newtype->acceptMutator( *visitor );
    141148        } // if
    142149}

  • src/SynTree/TypeSubstitution.h

    r2efe4b8 r1cdfa82  
    125125
    126126// definitition must happen after PassVisitor is included so that WithGuards can be used
    127 struct TypeSubstitution::Substituter : public WithGuards {
     127struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
    128128                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
    129129

  • src/SynTree/Visitor.h

    r2efe4b8 r1cdfa82  
    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;
    … …  
    6162        virtual void visit( NameExpr * nameExpr ) = 0;
    6263        virtual void visit( CastExpr * castExpr ) = 0;
     64        virtual void visit( KeywordCastExpr * castExpr ) = 0;
    6365        virtual void visit( VirtualCastExpr * castExpr ) = 0;
    6466        virtual void visit( AddressExpr * addressExpr ) = 0;

  • src/SynTree/module.mk

    r2efe4b8 r1cdfa82  
    4949       SynTree/Attribute.cc \
    5050       SynTree/BaseSyntaxNode.cc \
    51        SynTree/VarExprReplacer.cc
     51       SynTree/DeclReplacer.cc
    5252

  • src/benchmark/bench.h

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

  • src/libcfa/Makefile.am

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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    };
    … …  
    381381        signed int _index0 = 0;
    382382        for (;(_index0<10);((void)(++_index0))) {
    383             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index0)])))) /* ?{} */);
     383            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index0)]) /* ?{} */);
    384384        }
    385385
    … …  
    394394        signed int _index1 = 0;
    395395        for (;(_index1<10);((void)(++_index1))) {
    396             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index1)])))=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
     396            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index1)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
    397397        }
    398398
    … …  
    406406        signed int _index2 = (10-1);
    407407        for (;(_index2>=0);((void)(--_index2))) {
    408             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index2)])))) /* ^?{} */);
     408            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index2)]) /* ^?{} */);
    409409        }
    410410
    … …  
    436436        signed int _index4 = 0;
    437437        for (;(_index4<10);((void)(++_index4))) {
    438             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index4)])))) /* ?{} */);
     438            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index4)]) /* ?{} */);
    439439        }
    440440
    … …  
    449449        signed int _index5 = 0;
    450450        for (;(_index5<10);((void)(++_index5))) {
    451             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index5)])))) /* ?{} */);
     451            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index5)]) /* ?{} */);
    452452        }
    453453
    … …  
    462462        signed int _index6 = 0;
    463463        for (;(_index6<10);((void)(++_index6))) {
    464             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index6)])))=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
     464            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index6)]=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
    465465        }
    466466
    … …  
    475475        signed int _index7 = 0;
    476476        for (;(_index7<10);((void)(++_index7))) {
    477             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index7)])))=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
     477            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index7)]=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
    478478        }
    479479

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

    r2efe4b8 r1cdfa82  
    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    };
    … …  
    381381        signed int _index0 = 0;
    382382        for (;(_index0<10);((void)(++_index0))) {
    383             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index0])))) /* ?{} */);
     383            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index0]) /* ?{} */);
    384384        }
    385385
    … …  
    394394        signed int _index1 = 0;
    395395        for (;(_index1<10);((void)(++_index1))) {
    396             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index1])))=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
     396            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index1]=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
    397397        }
    398398
    … …  
    406406        signed int _index2 = (10-1);
    407407        for (;(_index2>=0);((void)(--_index2))) {
    408             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index2])))) /* ^?{} */);
     408            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index2]) /* ^?{} */);
    409409        }
    410410
    … …  
    436436        signed int _index4 = 0;
    437437        for (;(_index4<10);((void)(++_index4))) {
    438             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index4])))) /* ?{} */);
     438            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index4]) /* ?{} */);
    439439        }
    440440
    … …  
    449449        signed int _index5 = 0;
    450450        for (;(_index5<10);((void)(++_index5))) {
    451             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index5])))) /* ?{} */);
     451            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index5]) /* ?{} */);
    452452        }
    453453
    … …  
    462462        signed int _index6 = 0;
    463463        for (;(_index6<10);((void)(++_index6))) {
    464             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index6])))=__anonymous_object51[_index6]) /* ?{} */);
     464            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index6]=__anonymous_object51[_index6]) /* ?{} */);
    465465        }
    466466
    … …  
    475475        signed int _index7 = 0;
    476476        for (;(_index7<10);((void)(++_index7))) {
    477             ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index7])))=__anonymous_object54[_index7]) /* ?{} */);
     477            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
    478478        }
    479479

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

    r2efe4b8 r1cdfa82  
    193193    }
    194194    ((void)__extension__ sizeof(3));
    195     ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
     195    ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
    196196    ((void)__extension__ __alignof__(__extension__ __a__i_2));
    197     ((void)(((signed int )(__extension__ __a__i_2!=((signed int )0))) || ((signed int )((((signed int )(__extension__ __b__i_2!=((signed int )0))) && ((signed int )(__extension__ __c__i_2!=((signed int )0))))!=((signed int )0)))));
    198     ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     197    ((void)((__extension__ __a__i_2!=((signed int )0)) || (((__extension__ __b__i_2!=((signed int )0)) && (__extension__ __c__i_2!=((signed int )0)))!=((signed int )0))));
     198    ((void)(((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0)) ? __extension__ __c__i_2 : __extension__ __c__i_2));
    199199    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    200200    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));

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

    r2efe4b8 r1cdfa82  
    193193    }
    194194    ((void)__extension__ sizeof(3));
    195     ((void)__extension__ (((signed int )(3!=((signed int )0))) || ((signed int )(4!=((signed int )0)))));
     195    ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
    196196    ((void)__extension__ __alignof__(__extension__ __a__i_2));
    197     ((void)(((signed int )(__extension__ __a__i_2!=((signed int )0))) || ((signed int )((((signed int )(__extension__ __b__i_2!=((signed int )0))) && ((signed int )(__extension__ __c__i_2!=((signed int )0))))!=((signed int )0)))));
    198     ((void)(((signed int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     197    ((void)((__extension__ __a__i_2!=((signed int )0)) || (((__extension__ __b__i_2!=((signed int )0)) && (__extension__ __c__i_2!=((signed int )0)))!=((signed int )0))));
     198    ((void)(((__extension__ __a__i_2>__extension__ __b__i_2)!=((signed int )0)) ? __extension__ __c__i_2 : __extension__ __c__i_2));
    199199    ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
    200200    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));

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

    r2efe4b8 r1cdfa82  
    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,
    … …  
    154224        signed int _index0 = 0;
    155225        for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
    156             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index0)])))) /* ?{} */);
     226            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index0)]) /* ?{} */);
    157227        }
    158228
    … …  
    162232        signed int _index1 = 0;
    163233        for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
    164             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index1)])))) /* ?{} */);
     234            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index1)]) /* ?{} */);
    165235        }
    166236
    … …  
    177247        signed int _index2 = 0;
    178248        for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
    179             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index2)])))=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
     249            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index2)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
    180250        }
    181251
    … …  
    185255        signed int _index3 = 0;
    186256        for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
    187             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index3)])))=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index3)]) /* ?{} */);
     257            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index3)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index3)]) /* ?{} */);
    188258        }
    189259
    … …  
    195265        signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
    196266        for (;(_index4>=0);((void)(--_index4))) {
    197             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)])))) /* ^?{} */);
     267            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)]) /* ^?{} */);
    198268        }
    199269
    … …  
    203273        signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
    204274        for (;(_index5>=0);((void)(--_index5))) {
    205             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index5)])))) /* ^?{} */);
     275            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index5)]) /* ^?{} */);
    206276        }
    207277
    … …  
    249319        signed int _index8 = 0;
    250320        for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
    251             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index8)])))) /* ?{} */);
     321            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index8)]) /* ?{} */);
    252322        }
    253323
    … …  
    257327        signed int _index9 = 0;
    258328        for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
    259             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index9)])))) /* ?{} */);
     329            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index9)]) /* ?{} */);
    260330        }
    261331
    … …  
    272342        signed int _index10 = 0;
    273343        for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
    274             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index10)])))) /* ?{} */);
     344            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index10)]) /* ?{} */);
    275345        }
    276346
    … …  
    280350        signed int _index11 = 0;
    281351        for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
    282             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index11)])))) /* ?{} */);
     352            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index11)]) /* ?{} */);
    283353        }
    284354
    … …  
    295365        signed int _index12 = 0;
    296366        for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
    297             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index12)])))) /* ?{} */);
     367            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index12)]) /* ?{} */);
    298368        }
    299369
    … …  
    303373        signed int _index13 = 0;
    304374        for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
    305             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index13)])))) /* ?{} */);
     375            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index13)]) /* ?{} */);
    306376        }
    307377
    … …  
    318388        signed int _index14 = 0;
    319389        for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
    320             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index14)])))) /* ?{} */);
     390            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index14)]) /* ?{} */);
    321391        }
    322392
    … …  
    326396        signed int _index15 = 0;
    327397        for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
    328             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index15)])))) /* ?{} */);
     398            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index15)]) /* ?{} */);
    329399        }
    330400
    … …  
    341411        signed int _index16 = 0;
    342412        for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
    343             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index16)])))) /* ?{} */);
     413            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index16)]) /* ?{} */);
    344414        }
    345415
    … …  
    349419        signed int _index17 = 0;
    350420        for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
    351             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index17)])))) /* ?{} */);
     421            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index17)]) /* ?{} */);
    352422        }
    353423
    … …  
    364434        signed int _index18 = 0;
    365435        for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
    366             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)])))=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
     436            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)]=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
    367437        }
    368438
    … …  
    372442        signed int _index19 = 0;
    373443        for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
    374             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)])))) /* ?{} */);
     444            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)]) /* ?{} */);
    375445        }
    376446
    … …  
    387457        signed int _index20 = 0;
    388458        for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
    389             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)])))=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
     459            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)]=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
    390460        }
    391461
    … …  
    395465        signed int _index21 = 0;
    396466        for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
    397             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)])))=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
    398         }
    399 
    400     }
    401 
    402 }
    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, ...);
     467            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)]=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
     468        }
     469
     470    }
     471
     472}
     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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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

    r2efe4b8 r1cdfa82  
    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,
    … …  
    154224        signed int _index0 = 0;
    155225        for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
    156             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index0])))) /* ?{} */);
     226            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index0]) /* ?{} */);
    157227        }
    158228
    … …  
    162232        signed int _index1 = 0;
    163233        for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
    164             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index1])))) /* ?{} */);
     234            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index1]) /* ?{} */);
    165235        }
    166236
    … …  
    177247        signed int _index2 = 0;
    178248        for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
    179             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index2])))=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
     249            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index2]=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
    180250        }
    181251
    … …  
    185255        signed int _index3 = 0;
    186256        for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
    187             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index3])))=___src__9sofstream_1.__tupleSeparator__A0c_1[_index3]) /* ?{} */);
     257            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index3]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index3]) /* ?{} */);
    188258        }
    189259
    … …  
    195265        signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
    196266        for (;(_index4>=0);((void)(--_index4))) {
    197             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index4])))) /* ^?{} */);
     267            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index4]) /* ^?{} */);
    198268        }
    199269
    … …  
    203273        signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
    204274        for (;(_index5>=0);((void)(--_index5))) {
    205             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index5])))) /* ^?{} */);
     275            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index5]) /* ^?{} */);
    206276        }
    207277
    … …  
    249319        signed int _index8 = 0;
    250320        for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
    251             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index8])))) /* ?{} */);
     321            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index8]) /* ?{} */);
    252322        }
    253323
    … …  
    257327        signed int _index9 = 0;
    258328        for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
    259             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index9])))) /* ?{} */);
     329            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index9]) /* ?{} */);
    260330        }
    261331
    … …  
    272342        signed int _index10 = 0;
    273343        for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
    274             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index10])))) /* ?{} */);
     344            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index10]) /* ?{} */);
    275345        }
    276346
    … …  
    280350        signed int _index11 = 0;
    281351        for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
    282             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index11])))) /* ?{} */);
     352            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index11]) /* ?{} */);
    283353        }
    284354
    … …  
    295365        signed int _index12 = 0;
    296366        for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
    297             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index12])))) /* ?{} */);
     367            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index12]) /* ?{} */);
    298368        }
    299369
    … …  
    303373        signed int _index13 = 0;
    304374        for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
    305             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index13])))) /* ?{} */);
     375            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index13]) /* ?{} */);
    306376        }
    307377
    … …  
    318388        signed int _index14 = 0;
    319389        for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
    320             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index14])))) /* ?{} */);
     390            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index14]) /* ?{} */);
    321391        }
    322392
    … …  
    326396        signed int _index15 = 0;
    327397        for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
    328             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index15])))) /* ?{} */);
     398            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index15]) /* ?{} */);
    329399        }
    330400
    … …  
    341411        signed int _index16 = 0;
    342412        for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
    343             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index16])))) /* ?{} */);
     413            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index16]) /* ?{} */);
    344414        }
    345415
    … …  
    349419        signed int _index17 = 0;
    350420        for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
    351             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index17])))) /* ?{} */);
     421            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index17]) /* ?{} */);
    352422        }
    353423
    … …  
    364434        signed int _index18 = 0;
    365435        for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
    366             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index18])))=__separator__A0c_1[_index18]) /* ?{} */);
     436            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index18]=__separator__A0c_1[_index18]) /* ?{} */);
    367437        }
    368438
    … …  
    372442        signed int _index19 = 0;
    373443        for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
    374             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index19])))) /* ?{} */);
     444            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index19]) /* ?{} */);
    375445        }
    376446
    … …  
    387457        signed int _index20 = 0;
    388458        for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
    389             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index20])))=__separator__A0c_1[_index20]) /* ?{} */);
     459            ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index20]=__separator__A0c_1[_index20]) /* ?{} */);
    390460        }
    391461
    … …  
    395465        signed int _index21 = 0;
    396466        for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
    397             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21])))=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
    398         }
    399 
    400     }
    401 
    402 }
    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, ...);
     467            ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21]=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
     468        }
     469
     470    }
     471
     472}
     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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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=___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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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/.expect/preempt.txt

    r2efe4b8 r1cdfa82  
    44400
    55500
    6 600
    7 700
    8 800
    9 900
    10 1000

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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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}
     12
     13#ifdef LONG_TEST
     14static const unsigned long N = 30_000ul;
     15#else
     16static const unsigned long N = 500ul;
     17#endif
    1118
    1219static volatile int counter = 0;
    … …  
    2128
    2229void main(worker_t & this) {
    23         while(counter < 1000) {
     30        while(counter < N) {
    2431                if( (counter % 7) == this.value ) {
    2532                        int next = __atomic_add_fetch_4(&counter, 1, __ATOMIC_SEQ_CST);

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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

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

  • src/tests/preempt_longrun/create.c

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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

    r2efe4b8 r1cdfa82  
    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        r3 = 6;                               // change x, ***r3
     78        printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
     79        &r3 = &x2;                            // change r1 to refer to x2, (&*)**r3
     80        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, ensure explicit cast to reference works
     83        r3 = 12345;                           // modify x
     84        printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
     85        &&&r3 = p3;                           // change r3 to p3, (&(&(&*)*)*)r3
     86        ((int&)r3) = 22222;                   // modify x, ensure explicit cast to reference works
     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
Note: See TracChangeset for help on using the changeset viewer.