Changeset b6838214 for src


Ignore:
Timestamp:
Jan 23, 2018, 5:46:43 PM (8 years ago)
Author:
Alan Kennedy <afakenne@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
258e6ad5
Parents:
b158d8f (diff), 15d248e (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:

add context switch for ARM

Location:
src
Files:
8 added
13 deleted
95 edited
26 moved

Legend:

Unmodified
Added
Removed

  • src/CodeGen/FixMain.cc

    rb158d8f rb6838214  
    2323
    2424#include "Common/SemanticError.h"  // for SemanticError
     25#include "CodeGen/GenType.h"       // for GenType
    2526#include "SynTree/Declaration.h"   // for FunctionDecl, operator<<
    2627#include "SynTree/Type.h"          // for FunctionType
    … …  
    2930        bool FixMain::replace_main = false;
    3031        std::unique_ptr<FunctionDecl> FixMain::main_signature = nullptr;
     32
     33        template<typename container>
     34        std::string genTypeAt(const container& p, size_t idx) {
     35                return genType((*std::next(p.begin(), idx))->get_type(), "");
     36        }
    3137
    3238        void FixMain::registerMain(FunctionDecl* functionDecl)
    … …  
    4349
    4450                        os << main_signature->get_scopedMangleName() << "(";
    45                         switch(main_signature->get_functionType()->get_parameters().size()) {
    46                                 case 3: os << "argc, argv, envp"; break;
    47                                 case 2: os << "argc, argv"; break;
     51                        const auto& params = main_signature->get_functionType()->get_parameters();
     52                        switch(params.size()) {
     53                                case 3: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv, (" << genTypeAt(params, 2) << ")envp"; break;
     54                                case 2: os << "(" << genTypeAt(params, 0) << ")argc, (" << genTypeAt(params, 1) << ")argv"; break;
    4855                                case 0: break;
    4956                                default : assert(false);

  • src/CodeGen/GenType.cc

    rb158d8f rb6838214  
    2626
    2727namespace CodeGen {
    28         class GenType : public Visitor {
    29           public:
     28        struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
    3029                GenType( const std::string &typeString, bool pretty = false, bool genC = false, bool lineMarks = false );
    3130                std::string get_typeString() const { return typeString; }
    3231                void set_typeString( const std::string &newValue ) { typeString = newValue; }
    3332
    34                 virtual void visit( FunctionType *funcType );
    35                 virtual void visit( VoidType *voidType );
    36                 virtual void visit( BasicType *basicType );
    37                 virtual void visit( PointerType *pointerType );
    38                 virtual void visit( ArrayType *arrayType );
    39                 virtual void visit( ReferenceType *refType );
    40                 virtual void visit( StructInstType *structInst );
    41                 virtual void visit( UnionInstType *unionInst );
    42                 virtual void visit( EnumInstType *enumInst );
    43                 virtual void visit( TypeInstType *typeInst );
    44                 virtual void visit( TupleType * tupleType );
    45                 virtual void visit( VarArgsType *varArgsType );
    46                 virtual void visit( ZeroType *zeroType );
    47                 virtual void visit( OneType *oneType );
     33                void previsit( BaseSyntaxNode * );
     34                void postvisit( BaseSyntaxNode * );
     35
     36                void postvisit( FunctionType * funcType );
     37                void postvisit( VoidType * voidType );
     38                void postvisit( BasicType * basicType );
     39                void postvisit( PointerType * pointerType );
     40                void postvisit( ArrayType * arrayType );
     41                void postvisit( ReferenceType * refType );
     42                void postvisit( StructInstType * structInst );
     43                void postvisit( UnionInstType * unionInst );
     44                void postvisit( EnumInstType * enumInst );
     45                void postvisit( TypeInstType * typeInst );
     46                void postvisit( TupleType  * tupleType );
     47                void postvisit( VarArgsType * varArgsType );
     48                void postvisit( ZeroType * zeroType );
     49                void postvisit( OneType * oneType );
    4850
    4951          private:
    … …  
    5961
    6062        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
    61                 GenType gt( baseString, pretty, genC, lineMarks );
     63                PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks );
    6264                std::ostringstream os;
    6365
    … …  
    6870
    6971                type->accept( gt );
    70                 return os.str() + gt.get_typeString();
     72                return os.str() + gt.pass.get_typeString();
    7173        }
    7274
    … …  
    7779        GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
    7880
    79         void GenType::visit( VoidType *voidType ) {
     81        // *** BaseSyntaxNode
     82        void GenType::previsit( BaseSyntaxNode * ) {
     83                // turn off automatic recursion for all nodes, to allow each visitor to
     84                // precisely control the order in which its children are visited.
     85                visit_children = false;
     86        }
     87
     88        void GenType::postvisit( BaseSyntaxNode * node ) {
     89                std::stringstream ss;
     90                node->print( ss );
     91                assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
     92        }
     93
     94        void GenType::postvisit( VoidType * voidType ) {
    8095                typeString = "void " + typeString;
    8196                handleQualifiers( voidType );
    8297        }
    8398
    84         void GenType::visit( BasicType *basicType ) {
    85                 BasicType::Kind kind = basicType->get_kind();
     99        void GenType::postvisit( BasicType * basicType ) {
     100                BasicType::Kind kind = basicType->kind;
    86101                assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
    87102                typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
    … …  
    89104        }
    90105
    91         void GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) {
     106        void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) {
    92107                std::ostringstream os;
    93108                if ( typeString != "" ) {
    … …  
    126141                typeString = os.str();
    127142
    128                 base->accept( *this );
    129         }
    130 
    131         void GenType::visit( PointerType *pointerType ) {
    132                 assert( pointerType->get_base() != 0);
    133                 if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->get_dimension() ) {
    134                         genArray( pointerType->get_qualifiers(), pointerType->get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() );
     143                base->accept( *visitor );
     144        }
     145
     146        void GenType::postvisit( PointerType * pointerType ) {
     147                assert( pointerType->base != 0);
     148                if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) {
     149                        genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() );
    135150                } else {
    136151                        handleQualifiers( pointerType );
    … …  
    140155                                typeString = "*" + typeString;
    141156                        } // if
    142                         pointerType->get_base()->accept( *this );
    143                 } // if
    144         }
    145 
    146         void GenType::visit( ArrayType *arrayType ) {
    147                 genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
    148         }
    149 
    150         void GenType::visit( ReferenceType *refType ) {
    151                 assert( refType->get_base() != 0);
     157                        pointerType->base->accept( *visitor );
     158                } // if
     159        }
     160
     161        void GenType::postvisit( ArrayType * arrayType ) {
     162                genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() );
     163        }
     164
     165        void GenType::postvisit( ReferenceType * refType ) {
     166                assert( refType->base != 0);
    152167                assertf( ! genC, "Reference types should not reach code generation." );
    153168                handleQualifiers( refType );
    154169                typeString = "&" + typeString;
    155                 refType->get_base()->accept( *this );
    156         }
    157 
    158         void GenType::visit( FunctionType *funcType ) {
     170                refType->base->accept( *visitor );
     171        }
     172
     173        void GenType::postvisit( FunctionType * funcType ) {
    159174                std::ostringstream os;
    160175
    … …  
    169184                /************* parameters ***************/
    170185
    171                 const std::list<DeclarationWithType *> &pars = funcType->get_parameters();
     186                const std::list<DeclarationWithType *> &pars = funcType->parameters;
    172187
    173188                if ( pars.empty() ) {
    … …  
    191206                typeString = os.str();
    192207
    193                 if ( funcType->get_returnVals().size() == 0 ) {
     208                if ( funcType->returnVals.size() == 0 ) {
    194209                        typeString = "void " + typeString;
    195210                } else {
    196                         funcType->get_returnVals().front()->get_type()->accept( *this );
     211                        funcType->returnVals.front()->get_type()->accept( *visitor );
    197212                } // if
    198213
    199214                // add forall
    200                 if( ! funcType->get_forall().empty() && ! genC ) {
     215                if( ! funcType->forall.empty() && ! genC ) {
    201216                        // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
    202217                        std::ostringstream os;
    203218                        PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
    204219                        os << "forall(";
    205                         cg.pass.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
     220                        cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
    206221                        os << ")" << std::endl;
    207222                        typeString = os.str() + typeString;
    … …  
    221236        }
    222237
    223         void GenType::visit( StructInstType *structInst )  {
    224                 typeString = structInst->get_name() + handleGeneric( structInst ) + " " + typeString;
     238        void GenType::postvisit( StructInstType * structInst )  {
     239                typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
    225240                if ( genC ) typeString = "struct " + typeString;
    226241                handleQualifiers( structInst );
    227242        }
    228243
    229         void GenType::visit( UnionInstType *unionInst ) {
    230                 typeString = unionInst->get_name() + handleGeneric( unionInst ) + " " + typeString;
     244        void GenType::postvisit( UnionInstType * unionInst ) {
     245                typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
    231246                if ( genC ) typeString = "union " + typeString;
    232247                handleQualifiers( unionInst );
    233248        }
    234249
    235         void GenType::visit( EnumInstType *enumInst ) {
    236                 typeString = enumInst->get_name() + " " + typeString;
     250        void GenType::postvisit( EnumInstType * enumInst ) {
     251                typeString = enumInst->name + " " + typeString;
    237252                if ( genC ) typeString = "enum " + typeString;
    238253                handleQualifiers( enumInst );
    239254        }
    240255
    241         void GenType::visit( TypeInstType *typeInst ) {
    242                 typeString = typeInst->get_name() + " " + typeString;
     256        void GenType::postvisit( TypeInstType * typeInst ) {
     257                typeString = typeInst->name + " " + typeString;
    243258                handleQualifiers( typeInst );
    244259        }
    245260
    246         void GenType::visit( TupleType * tupleType ) {
     261        void GenType::postvisit( TupleType * tupleType ) {
    247262                assertf( ! genC, "Tuple types should not reach code generation." );
    248263                unsigned int i = 0;
    … …  
    257272        }
    258273
    259         void GenType::visit( VarArgsType *varArgsType ) {
     274        void GenType::postvisit( VarArgsType * varArgsType ) {
    260275                typeString = "__builtin_va_list " + typeString;
    261276                handleQualifiers( varArgsType );
    262277        }
    263278
    264         void GenType::visit( ZeroType *zeroType ) {
     279        void GenType::postvisit( ZeroType * zeroType ) {
    265280                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
    266281                typeString = (pretty ? "zero_t " : "long int ") + typeString;
    … …  
    268283        }
    269284
    270         void GenType::visit( OneType *oneType ) {
     285        void GenType::postvisit( OneType * oneType ) {
    271286                // ideally these wouldn't hit codegen at all, but should be safe to make them ints
    272287                typeString = (pretty ? "one_t " : "long int ") + typeString;
    … …  
    274289        }
    275290
    276         void GenType::handleQualifiers( Type *type ) {
     291        void GenType::handleQualifiers( Type * type ) {
    277292                if ( type->get_const() ) {
    278293                        typeString = "const " + typeString;

  • src/CodeTools/DeclStats.cc

    rb158d8f rb6838214  
    2323#include <utility>                 // for pair, make_pair
    2424
     25#include "Common/PassVisitor.h"
    2526#include "Common/SemanticError.h"  // for SemanticError
    2627#include "Common/VectorMap.h"      // for VectorMap
    … …  
    3536namespace CodeTools {
    3637
    37         class DeclStats : public Visitor {
     38        struct DeclStats : public WithShortCircuiting {
    3839                template<typename T>
    3940                static void sum(T& a, const T& b) { a += b; }
    … …  
    6162
    6263                struct ArgPackStats {
    63                         VectorMap<unsigned> n;                 ///< Count of decls with each number of elements
    64                         VectorMap<unsigned> n_basic;           ///< Count of decls with each number of basic type elements
    65                         VectorMap<unsigned> n_poly;            ///< Count of decls with each number of polymorphic elements
    66                         std::map<unsigned, unsigned> p_basic;  ///< Count of decls with each percentage of basic type elements
    67                         std::map<unsigned, unsigned> p_poly;   ///< Count of decls with each percentage of polymorphic elements
    68                         VectorMap<unsigned> n_types;           ///< Count of decls with each number of distinct types in the pack
     64                        VectorMap<unsigned> n;                   ///< Count of decls with each number of elements
     65                        VectorMap<unsigned> n_basic;             ///< Count of decls with each number of basic type elements
     66                        VectorMap<unsigned> n_generic;           ///< Count of decls with each number of generic type elements
     67                        VectorMap<unsigned> n_poly;              ///< Count of decls with each number of polymorphic elements
     68                        VectorMap<unsigned> n_compound;          ///< Count of decls with each number of non-generic compound types
     69                        std::map<unsigned, unsigned> p_basic;    ///< Count of decls with each percentage of basic type elements
     70                        std::map<unsigned, unsigned> p_generic;  ///< Count of decls with each percentage of generic type elements
     71                        std::map<unsigned, unsigned> p_poly;     ///< Count of decls with each percentage of polymorphic elements
     72                        std::map<unsigned, unsigned> p_compound; ///< Count of decls with each percentage of non-generic compound type elements
     73                        VectorMap<unsigned> n_types;             ///< Count of decls with each number of distinct types in the pack
    6974                        /// Count of decls with each percentage of new types in lists.
    7075                        /// Types used in the parameter list that recur in the return list are not considered to be new.
    … …  
    7479                                sum(n, o.n);
    7580                                sum(n_basic, o.n_basic);
     81                                sum(n_generic, o.n_generic);
    7682                                sum(n_poly, o.n_poly);
     83                                sum(n_compound, o.n_compound);
    7784                                sum(p_basic, o.p_basic);
     85                                sum(p_generic, o.p_generic);
    7886                                sum(p_poly, o.p_poly);
     87                                sum(p_compound, o.p_compound);
    7988                                sum(n_types, o.n_types);
    8089                                sum(p_new, o.p_new);
    … …  
    8897                        /// Count of declarations with each number of assertion parameters
    8998                        VectorMap<unsigned> n_type_params;
     99                        /// Count of generic types with each number of type parameters
     100                        VectorMap<unsigned> n_generic_params;
     101                        /// Count of maximum nesting depth of types
     102                        VectorMap<unsigned> n_generic_nesting;
    90103                        /// Count of declarations with each name
    91104                        std::unordered_map<std::string, unsigned> by_name;
    92105                        /// Count of uses of each basic type
    93106                        std::unordered_map<std::string, unsigned> basic_type_names;
    94                         /// Count of uses of each non-basic type
     107                        /// Count of uses of each generic type name (includes "*", "[]", "(*)", "[,]")
     108                        std::unordered_map<std::string, unsigned> generic_type_names;
     109                        /// Count of uses of each non-generic aggregate type
    95110                        std::unordered_map<std::string, unsigned> compound_type_names;
    96111                        /// Count of decls using each basic type
    97112                        std::unordered_map<std::string, unsigned> basic_type_decls;
     113                        /// Count of decls using each generic type (includes "*", "[]", "(*)", "[,]")
     114                        std::unordered_map<std::string, unsigned> generic_type_decls;
    98115                        /// Count of decls using each compound type
    99116                        std::unordered_map<std::string, unsigned> compound_type_decls;
    … …  
    110127                        ArgPackStats assn_returns;
    111128
    112                         Stats() : n_decls(0), n_type_params(), by_name(), basic_type_names(), compound_type_names(), basic_type_decls(), compound_type_decls(), params(), returns(), n_assns(), assn_params(), assn_returns() {}
     129                        Stats() : n_decls(0), n_type_params(), n_generic_params(), n_generic_nesting(),
     130                                by_name(), basic_type_names(), generic_type_names(), compound_type_names(),
     131                                basic_type_decls(), generic_type_decls(), compound_type_decls(), params(),
     132                                returns(), n_assns(), assn_params(), assn_returns() {}
    113133
    114134                public:
    … …  
    116136                                sum( n_decls, o.n_decls );
    117137                                sum( n_type_params, o.n_type_params );
     138                                sum( n_generic_params, o.n_generic_params );
     139                                sum( n_generic_nesting, o.n_generic_nesting );
    118140                                sum( by_name, o.by_name );
    119141                                sum( basic_type_names, o.basic_type_names );
     142                                sum( generic_type_names, o.generic_type_names );
    120143                                sum( compound_type_names, o.compound_type_names );
    121144                                sum( basic_type_decls, o.basic_type_decls );
     145                                sum( generic_type_decls, o.generic_type_decls );
    122146                                sum( compound_type_decls, o.compound_type_decls );
    123147                                sum( params, o.params );
    … …  
    131155                };
    132156
    133                 Stats for_linkage[LinkageSpec::NoOfSpecs];   ///< Stores separate stats per linkage
     157                /// number of counting bins for linkages
     158                static const unsigned n_named_specs = 8;
     159                /// map from total number of specs to bins
     160                static const unsigned ind_for_linkage[16];
     161
     162                Stats for_linkage[n_named_specs];            ///< Stores separate stats per linkage
    134163                std::unordered_set<std::string> seen_names;  ///< Stores manglenames already seen to avoid double-counting
    135164                Stats total;
    … …  
    137166                std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth;
    138167
     168                void countType( const std::string& name, unsigned& n, std::unordered_map<std::string,
     169                                unsigned>& names, std::unordered_map<std::string, unsigned>& decls,
     170                                std::unordered_set<std::string>& elSeen ) {
     171                        ++n;
     172                        ++names[ name ];
     173                        if ( elSeen.insert( name ).second ) { ++decls[ name ]; }
     174                }
     175
     176                void update_max( unsigned& max, unsigned crnt ) {
     177                        if ( crnt > max ) max = crnt;
     178                }
     179
     180                void analyzeSubtype( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen,
     181                                unsigned& n_poly, bool& seen_poly, unsigned& max_depth, unsigned depth ) {
     182                        unsigned x;
     183                        analyzeType( ty, stats, elSeen, x, x, n_poly, x, seen_poly, max_depth, depth + 1 );
     184                }
     185
     186                void analyzeSubtypes( std::list<DeclarationWithType*>& tys, Stats& stats,
     187                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
     188                                unsigned& max_depth, unsigned depth, unsigned& n_subs ) {
     189                        for ( DeclarationWithType* dwt : tys ) {
     190                                Type* ty = dwt->get_type();
     191                                n_subs += (unsigned)( dynamic_cast<VoidType*>(ty) != nullptr );
     192                                analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth );
     193                        }
     194                }
     195
     196                void analyzeSubtypes( std::list<Expression*>& tys, Stats& stats,
     197                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
     198                                unsigned& max_depth, unsigned depth ) {
     199                        for ( Expression* expr : tys ) {
     200                                TypeExpr* texpr = dynamic_cast<TypeExpr*>(expr);
     201                                if ( ! texpr ) continue;
     202                                Type* ty = texpr->get_type();
     203                                analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth );
     204                        }
     205                }
     206
     207                void analyzeSubtypes( std::list<Type*>& tys, Stats& stats,
     208                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
     209                                unsigned& max_depth, unsigned depth ) {
     210                        for ( Type* ty : tys ) {
     211                                analyzeSubtype( ty, stats, elSeen, n_poly, seen_poly, max_depth, depth );
     212                        }
     213                }
     214
     215                void analyzeType( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen,
     216                                unsigned& n_basic, unsigned& n_generic, unsigned& n_poly, unsigned& n_agg,
     217                                bool& seen_poly, unsigned& max_depth, unsigned depth = 0 ) {
     218                        if ( BasicType* bt = dynamic_cast<BasicType*>(ty) ) {
     219                                std::string name = BasicType::typeNames[ bt->get_kind() ];
     220                                countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen );
     221                                update_max( max_depth, depth );
     222                        } else if ( PointerType* pt = dynamic_cast<PointerType*>(ty) ) {
     223                                std::string name = "*";
     224                                countType(
     225                                        name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
     226                                analyzeSubtype(
     227                                        pt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
     228                                ++stats.n_generic_params.at( 1 );
     229                        } else if ( ArrayType* at = dynamic_cast<ArrayType*>(ty) ) {
     230                                std::string name = "[]";
     231                                countType(
     232                                        name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
     233                                analyzeSubtype(
     234                                        at->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
     235                                ++stats.n_generic_params.at( 1 );
     236                        } else if ( ReferenceType* rt = dynamic_cast<ReferenceType*>(ty) ) {
     237                                std::string name = "&";
     238                                countType(
     239                                        name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
     240                                analyzeSubtype(
     241                                        rt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
     242                                ++stats.n_generic_params.at( 1 );
     243                        } else if ( FunctionType* ft = dynamic_cast<FunctionType*>(ty) ) {
     244                                std::string name = "(*)";
     245                                countType(
     246                                        name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
     247                                unsigned n_subs = 0;
     248                                analyzeSubtypes(
     249                                        ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth,
     250                                        n_subs );
     251                                analyzeSubtypes(
     252                                        ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth,
     253                                        n_subs );
     254                                ++stats.n_generic_params.at( n_subs );
     255                        } else if ( TypeInstType* vt = dynamic_cast<TypeInstType*>(ty) ) {
     256                                if ( ! seen_poly ) {
     257                                        ++n_poly;
     258                                        seen_poly = true;
     259                                }
     260                                countType(
     261                                        vt->get_name(), n_agg, stats.compound_type_names, stats.compound_type_decls,
     262                                        elSeen );
     263                                update_max( max_depth, depth );
     264                        } else if ( ReferenceToType* st = dynamic_cast<ReferenceToType*>(ty) ) {
     265                                std::list<Expression*>& params = st->get_parameters();
     266                                if ( params.empty() ) {
     267                                        countType(
     268                                                st->get_name(), n_agg, stats.compound_type_names,
     269                                                stats.compound_type_decls, elSeen );
     270                                        update_max( max_depth, depth );
     271                                } else {
     272                                        countType(
     273                                                st->get_name(), n_generic, stats.generic_type_names,
     274                                                stats.generic_type_decls, elSeen);
     275                                        analyzeSubtypes( params, stats, elSeen, n_poly, seen_poly, max_depth, depth );
     276                                        ++stats.n_generic_params.at( params.size() );
     277                                }
     278                        } else if ( TupleType* tt = dynamic_cast<TupleType*>(ty) ) {
     279                                std::string name = "[,]";
     280                                countType(
     281                                        name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
     282                                analyzeSubtypes(
     283                                        tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
     284                                ++stats.n_generic_params.at( tt->size() );
     285                        } else if ( dynamic_cast<VarArgsType*>(ty) ) {
     286                                std::string name = "...";
     287                                countType(
     288                                        name, n_agg, stats.compound_type_names, stats.compound_type_decls, elSeen );
     289                                update_max( max_depth, depth );
     290                        } else if ( dynamic_cast<ZeroType*>(ty) ) {
     291                                std::string name = "0";
     292                                countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen );
     293                                update_max( max_depth, depth );
     294                        } else if ( dynamic_cast<OneType*>(ty) ) {
     295                                std::string name = "1";
     296                                countType( name, n_basic, stats.basic_type_names, stats.basic_type_decls, elSeen );
     297                                update_max( max_depth, depth );
     298                        }
     299                }
     300
    139301                /// Update arg pack stats based on a declaration list
    140                 void analyze( Stats& stats, std::unordered_set<std::string>& seen, ArgPackStats& pstats, std::list<DeclarationWithType*>& decls ) {
     302                void analyze( Stats& stats, std::unordered_set<std::string>& seen,
     303                                std::unordered_set<std::string>& elSeen, ArgPackStats& pstats,
     304                                std::list<DeclarationWithType*>& decls ) {
    141305                        std::unordered_set<std::string> types;
    142                         unsigned n = 0;        ///< number of args/returns
    143                         unsigned n_basic = 0;  ///< number of basic types
    144                         unsigned n_poly = 0;   ///< number of polymorphic types
    145                         unsigned n_new = 0;    ///< number of new types
     306                        unsigned n = 0;                 ///< number of args/returns
     307                        unsigned n_basic = 0;           ///< number of basic types
     308                        unsigned n_generic = 0;         ///< number of generic types (includes "*", "&", "[]", "(*)", "[,]")
     309                        unsigned n_poly = 0;            ///< number of polymorphic types
     310                        unsigned n_agg = 0;             ///< number of non-generic aggregate types
     311                        unsigned n_new = 0;             ///< number of new types
     312
    146313                        for ( auto decl : decls ) {
    147314                                Type* dt = decl->get_type();
    … …  
    152319                                dt->print( ss );
    153320                                types.insert( ss.str() );
    154                                 bool this_new = seen.insert( ss.str() ).second;
    155                                 if ( this_new ) { ++n_new; }
    156 
    157                                 if ( dynamic_cast<BasicType*>( dt ) ) {
    158                                         ++n_basic;
    159                                         ++stats.basic_type_names[ ss.str() ];
    160                                         if ( this_new ) {
    161                                                 ++stats.basic_type_decls[ ss.str() ];
    162                                         }
    163                                 } else if ( GenPoly::hasPolyBase( dt ) ) {
    164                                         ++n_poly;
    165                                 } else {
    166                                         ++stats.compound_type_names[ ss.str() ];
    167                                         if ( this_new ) {
    168                                                 ++stats.compound_type_decls[ ss.str() ];
    169                                         }
    170                                 }
    171                         }
     321                                if ( seen.insert( ss.str() ).second ) { ++n_new; }
     322
     323                                bool seen_poly = false;
     324                                unsigned max_depth = 0;
     325                                analyzeType(
     326                                        dt, stats, elSeen, n_basic, n_generic, n_poly, n_agg, seen_poly, max_depth );
     327                                ++stats.n_generic_nesting.at( max_depth );
     328                        }
     329
    172330                        ++pstats.n.at( n );
    173331                        ++pstats.n_basic.at( n_basic );
     332                        ++pstats.n_generic.at( n_generic );
    174333                        ++pstats.n_poly.at( n_poly );
     334                        ++pstats.n_compound.at( n_agg );
    175335                        if ( n > 0 ) {
    176336                                ++pstats.p_basic[ n_basic*100/n ];
     337                                ++pstats.p_generic[ n_generic*100/n ];
    177338                                ++pstats.p_poly[ n_poly*100/n ];
    178                                 ++pstats.p_new[ n_new*100/n ];
     339                                ++pstats.p_compound[ n_agg*100/n ];
     340                                if ( n > 1 ) ++pstats.p_new[ (n_new-1)*100/(n-1) ];
    179341                        }
    180342                        ++pstats.n_types.at( types.size() );
    … …  
    183345                void analyzeFunc( FunctionType* fnTy, Stats& stats, ArgPackStats& params, ArgPackStats& returns ) {
    184346                        std::unordered_set<std::string> seen;
    185                         analyze( stats, seen, params, fnTy->get_parameters() );
    186                         analyze( stats, seen, returns, fnTy->get_returnVals() );
     347                        std::unordered_set<std::string> elSeen;
     348                        analyze( stats, seen, elSeen, params, fnTy->get_parameters() );
     349                        analyze( stats, seen, elSeen, returns, fnTy->get_returnVals() );
    187350                }
    188351
    … …  
    200363
    201364        public:
    202                 using Visitor::visit;
    203 
    204                 virtual void visit( FunctionDecl *decl ) {
     365                void previsit( FunctionDecl *decl ) {
    205366                        // skip if already seen declaration for this function
    206                         const std::string& mangleName = decl->get_mangleName().empty() ? decl->get_name() : decl->get_mangleName();
    207                         if ( ! seen_names.insert( mangleName ).second ) {
    208                                 maybeAccept( decl->get_statements(), *this );
    209                                 return;
    210                         }
    211 
    212                         Stats& stats = for_linkage[ decl->get_linkage() ];
    213 
    214                         ++stats.n_decls;
    215                         FunctionType* fnTy = decl->get_functionType();
    216                         const Type::ForallList& forall = fnTy->get_forall();
    217                         ++stats.n_type_params.at( forall.size() );
    218                         unsigned n_assns = 0;
    219                         for ( TypeDecl* fdecl : forall ) {
    220                                 n_assns += fdecl->get_assertions().size();
    221                                 for ( DeclarationWithType* assn : fdecl->get_assertions() ) {
    222                                         FunctionType *assnTy = 0;
    223                                         if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) {
    224                                                 if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) {
    225                                                         assnTy = dynamic_cast<FunctionType*>(ptrTy->get_base());
    226                                                 } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type());
    227                                         } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) {
    228                                                 assnTy = assnDecl->get_functionType();
     367                        const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
     368                        if ( seen_names.insert( mangleName ).second ) {
     369                                Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
     370
     371                                ++stats.n_decls;
     372                                FunctionType* fnTy = decl->type;
     373                                const Type::ForallList& forall = fnTy->forall;
     374                                ++stats.n_type_params.at( forall.size() );
     375                                unsigned n_assns = 0;
     376                                for ( TypeDecl* fdecl : forall ) {
     377                                        n_assns += fdecl->assertions.size();
     378                                        for ( DeclarationWithType* assn : fdecl->assertions ) {
     379                                                FunctionType *assnTy = nullptr;
     380                                                if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) {
     381                                                        if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) {
     382                                                                assnTy = dynamic_cast<FunctionType*>(ptrTy->base);
     383                                                        } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type());
     384                                                } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) {
     385                                                        assnTy = assnDecl->type;
     386                                                }
     387                                                if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
    229388                                        }
    230                                         if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
    231                                 }
    232                         }
    233                         ++stats.n_assns[ n_assns ];
    234 
    235                         ++stats.by_name[ decl->get_name() ];
    236 
    237                         analyzeFunc( fnTy, stats, stats.params, stats.returns );
    238 
    239                         // analyze expressions in decl statements
    240                         maybeAccept( decl->get_statements(), *this );
    241                 }
    242 
    243                 virtual void visit( UntypedExpr *expr ) {
     389                                }
     390                                ++stats.n_assns[ n_assns ];
     391                                ++stats.by_name[ decl->name ];
     392                                analyzeFunc( fnTy, stats, stats.params, stats.returns );
     393                        }
     394                }
     395
     396                void previsit( UntypedExpr *expr ) {
     397                        visit_children = false;
    244398                        analyzeExpr( expr, 0 );
    245399                }
    … …  
    272426                template<typename F>
    273427                void printAllHisto( const std::string& name, F extract ) {
    274                         VectorMap<unsigned> histos[LinkageSpec::NoOfSpecs];
     428                        VectorMap<unsigned> histos[n_named_specs];
    275429                        VectorMap<unsigned> thisto;
    276430
    277431                        for ( const auto& entry : extract(total) ) { ++thisto.at( entry.second ); }
    278432
    279                         for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {
     433                        for ( unsigned i = 0; i < n_named_specs; ++i ) {
    280434                                // can't be a higher count in one of the sub-histograms than the total
    281435                                histos[i].reserve( thisto.size() );
    … …  
    295449                template<typename F>
    296450                void printAllSparseHisto( const std::string& name, F extract ) {
    297                         std::map<unsigned, unsigned> histos[LinkageSpec::NoOfSpecs];
     451                        std::map<unsigned, unsigned> histos[n_named_specs];
    298452                        std::map<unsigned, unsigned> thisto;
    299453
    300454                        for ( const auto& entry : extract(total) ) { ++thisto[ entry.second ]; }
    301455
    302                         for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {
     456                        for ( unsigned i = 0; i < n_named_specs; ++i ) {
    303457                                for ( const auto& entry : extract(for_linkage[i]) ) { ++histos[i][entry.second]; }
    304458                        }
    … …  
    307461                                const auto& key = entry.first;
    308462                                std::cout << "\"" << name << "\"," << key;
    309                                 for ( unsigned i = 0; i < LinkageSpec::NoOfSpecs; ++i ) {
     463                                for ( unsigned i = 0; i < n_named_specs; ++i ) {
    310464                                        auto it = histos[i].find( key );
    311465                                        if ( it == histos[i].end() ) std::cout << ",0";
    … …  
    319473                void printAllPack( const std::string& name, F extract ) {
    320474                        printAllMap("n_basic_" + name, [&extract](const Stats& stats) { return extract(stats).n_basic; });
     475                        printAllMap("n_generic_" + name, [&extract](const Stats& stats) { return extract(stats).n_generic; });
    321476                        printAllMap("n_poly_" + name, [&extract](const Stats& stats) { return extract(stats).n_poly; });
     477                        printAllMap("n_compound_" + name, [&extract](const Stats& stats) { return extract(stats).n_compound; });
    322478                        printAllMap("n_" + name, [&extract](const Stats& stats) { return extract(stats).n; });
    323479                        printAllMap("%_basic_" + name, [&extract](const Stats& stats) { return extract(stats).p_basic; });
     480                        printAllMap("%_generic_" + name, [&extract](const Stats& stats) { return extract(stats).p_generic; });
    324481                        printAllMap("%_poly_" + name, [&extract](const Stats& stats) { return extract(stats).p_poly; });
     482                        printAllMap("%_compound_" + name, [&extract](const Stats& stats) { return extract(stats).p_compound; });
    325483                        printAllMap("n_distinct_types_" + name, [&extract](const Stats& stats) { return extract(stats).n_types; });
    326484                        printAllMap("%_new_types_in_" + name, [&extract](const Stats& stats) { return extract(stats).p_new; });
    … …  
    342500                        }
    343501
    344                         std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"builtin\",\"TOTAL\"" << std::endl;
     502                        std::cout << ",,\"intrinsic\",\"Cforall\",\"C\",\"autogen\",\"compiler\",\"builtinCFA\",\"builtinC\",\"other\",\"TOTAL\"" << std::endl;
    345503
    346504                        printAllMap("n_type_params", [](const Stats& stats) { return stats.n_type_params; });
     505                        printAllMap("n_generic_params", [](const Stats& stats) { return stats.n_generic_params; });
     506                        printAllMap("n_generic_nesting", [](const Stats& stats) { return stats.n_generic_nesting; });
    347507                        printAll("n_decls", [](const Stats& stats) { return stats.n_decls; });
    348508                        printAll("unique_names", [](const Stats& stats) { return stats.by_name.size(); });
    … …  
    351511                        printAllSparseHisto("basic_type_uses", [](const Stats& stats) { return stats.basic_type_names; });
    352512                        printAllSparseHisto("decls_using_basic_type", [](const Stats& stats) { return stats.basic_type_decls; });
     513                        printAll("generic_type_names", [](const Stats& stats) { return stats.generic_type_names.size(); });
     514                        printAllSparseHisto("generic_type_uses", [](const Stats& stats) { return stats.generic_type_names; });
     515                        printAllSparseHisto("decls_using_generic_type", [](const Stats& stats) { return stats.generic_type_decls; });
    353516                        printAll("compound_type_names", [](const Stats& stats) { return stats.compound_type_names.size(); });
    354517                        printAllSparseHisto("compound_type_uses", [](const Stats& stats) { return stats.compound_type_names; });
    … …  
    365528        };
    366529
     530        const unsigned DeclStats::ind_for_linkage[]
     531                = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
     532
    367533        void printDeclStats( std::list< Declaration * > &translationUnit ) {
    368                 DeclStats stats;
     534                PassVisitor<DeclStats> stats;
    369535                acceptAll( translationUnit, stats );
    370                 stats.print();
     536                stats.pass.print();
    371537        }
    372538

  • src/CodeTools/TrackLoc.cc

    rb158d8f rb6838214  
    6464                                }
    6565                                else {
    66                                         assertf( false, "Top level node has no CodeLocation %s", name.c_str() );
     66                                        assertf( false, "Top level node has no CodeLocation %s", toString( node ).c_str() );
    6767                                }
    6868                        }

  • src/Common/PassVisitor.h

    rb158d8f rb6838214  
    1919#include "SynTree/Expression.h"
    2020#include "SynTree/Constant.h"
    21 #include "SynTree/TypeSubstitution.h"
     21
     22class TypeSubstitution;
    2223
    2324#include "PassVisitor.proto.h"
    … …  
    118119        virtual void visit( StmtExpr *  stmtExpr ) override final;
    119120        virtual void visit( UniqueExpr *  uniqueExpr ) override final;
     121        virtual void visit( UntypedInitExpr *  initExpr ) override final;
     122        virtual void visit( InitExpr *  initExpr ) override final;
    120123
    121124        virtual void visit( VoidType * basicType ) override final;
    … …  
    210213        virtual Expression * mutate( StmtExpr *  stmtExpr ) override final;
    211214        virtual Expression * mutate( UniqueExpr *  uniqueExpr ) override final;
     215        virtual Expression * mutate( UntypedInitExpr *  initExpr ) override final;
     216        virtual Expression * mutate( InitExpr *  initExpr ) override final;
    212217
    213218        virtual Type * mutate( VoidType * basicType ) override final;
    … …  
    403408};
    404409
     410#include "SynTree/TypeSubstitution.h"
    405411#include "PassVisitor.impl.h"

  • src/Common/PassVisitor.impl.h

    rb158d8f rb6838214  
    6262
    6363template< typename pass_type >
    64 static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
     64inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
    6565        DeclList_t* beforeDecls = visitor.get_beforeDecls();
    6666        DeclList_t* afterDecls  = visitor.get_afterDecls();
    … …  
    9090
    9191template< typename pass_type >
    92 static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
     92inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
    9393        DeclList_t* beforeDecls = mutator.get_beforeDecls();
    9494        DeclList_t* afterDecls  = mutator.get_afterDecls();
    … …  
    18531853}
    18541854
     1855//--------------------------------------------------------------------------
     1856// UntypedInitExpr
     1857template< typename pass_type >
     1858void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) {
     1859        VISIT_START( node );
     1860
     1861        indexerScopedAccept( node->result, *this );
     1862        maybeAccept_impl   ( node->expr  , *this );
     1863        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
     1864
     1865        VISIT_END( node );
     1866}
     1867
     1868template< typename pass_type >
     1869Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) {
     1870        MUTATE_START( node );
     1871
     1872        indexerScopedMutate( node->env   , *this );
     1873        indexerScopedMutate( node->result, *this );
     1874        maybeMutate_impl   ( node->expr  , *this );
     1875        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
     1876
     1877        MUTATE_END( Expression, node );
     1878}
     1879
     1880//--------------------------------------------------------------------------
     1881// InitExpr
     1882template< typename pass_type >
     1883void PassVisitor< pass_type >::visit( InitExpr * node ) {
     1884        VISIT_START( node );
     1885
     1886        indexerScopedAccept( node->result, *this );
     1887        maybeAccept_impl   ( node->expr  , *this );
     1888        maybeAccept_impl   ( node->designation, *this );
     1889
     1890        VISIT_END( node );
     1891}
     1892
     1893template< typename pass_type >
     1894Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) {
     1895        MUTATE_START( node );
     1896
     1897        indexerScopedMutate( node->env   , *this );
     1898        indexerScopedMutate( node->result, *this );
     1899        maybeMutate_impl   ( node->expr  , *this );
     1900        maybeMutate_impl   ( node->designation, *this );
     1901
     1902        MUTATE_END( Expression, node );
     1903}
     1904
    18551905template< typename pass_type >
    18561906void PassVisitor< pass_type >::visit( VoidType * node ) {

  • src/Concurrency/Keywords.cc

    rb158d8f rb6838214  
    257257        // Generic keyword implementation
    258258        //=============================================================================================
     259        void fixupGenerics(FunctionType * func, StructDecl * decl) {
     260                cloneAll(decl->parameters, func->forall);
     261                for ( TypeDecl * td : func->forall ) {
     262                        strict_dynamic_cast<StructInstType*>(
     263                                func->parameters.front()->get_type()->stripReferences()
     264                        )->parameters.push_back(
     265                                new TypeExpr( new TypeInstType( noQualifiers, td->name, td ) )
     266                        );
     267                }
     268        }
     269
    259270        void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
    260271                if( decl->name == type_name && decl->body ) {
    … …  
    301312                );
    302313
    303                 get_type->get_parameters().push_back( this_decl );
     314                get_type->get_parameters().push_back( this_decl->clone() );
    304315                get_type->get_returnVals().push_back(
    305316                        new ObjectDecl(
    … …  
    318329                        )
    319330                );
     331                fixupGenerics(get_type, decl);
    320332
    321333                FunctionDecl * get_decl = new FunctionDecl(
    … …  
    343355                                nullptr
    344356                        );
    345                 }
     357                        fixupGenerics(main_type, decl);
     358                }
     359
     360                delete this_decl;
    346361
    347362                declsToAddBefore.push_back( forward );
    … …  
    377392                                        new MemberExpr(
    378393                                                field,
    379                                                 UntypedExpr::createDeref( new VariableExpr( func->get_functionType()->get_parameters().front() ) )
     394                                                new CastExpr(
     395                                                        new VariableExpr( func->get_functionType()->get_parameters().front() ),
     396                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone()
     397                                                )
    380398                                        )
    381399                                )

  • src/Concurrency/Waitfor.cc

    rb158d8f rb6838214  
    507507                        new ListInit({
    508508                                new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
    509                                 new SingleInit( new VariableExpr( acceptables ) ),
    510                                 new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
     509                                new ListInit({
     510                                        new SingleInit( new VariableExpr( acceptables ) ),
     511                                        new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
     512                                })
    511513                        })
    512514                );

  • src/ControlStruct/ExceptTranslate.cc

    rb158d8f rb6838214  
    316316                                VarExprReplacer::DeclMap mapping;
    317317                                mapping[ handler_decl ] = local_except;
    318                                 VarExprReplacer mapper( mapping );
    319                                 handler->get_body()->accept( mapper );
     318                                VarExprReplacer::replace( handler->body, mapping );
    320319                        }
    321320

  • src/ControlStruct/LabelFixer.cc

    rb158d8f rb6838214  
    4444
    4545        void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
    46                 MLEMutator mlemut( resolveJumps(), generator );
     46                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
    4747                functionDecl->acceptMutator( mlemut );
    4848        }

  • src/ControlStruct/MLEMutator.cc

    rb158d8f rb6838214  
    4646        void MLEMutator::fixBlock( std::list< Statement * > &kids ) {
    4747                for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) {
    48                         *k = (*k)->acceptMutator(*this);
     48                        *k = (*k)->acceptMutator(*visitor);
    4949
    5050                        if ( ! get_breakLabel().empty() ) {
    … …  
    5757        }
    5858
    59         CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) {
    60                 bool labeledBlock = !(cmpndStmt->get_labels().empty());
     59        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
     60                visit_children = false;
     61                bool labeledBlock = !(cmpndStmt->labels.empty());
    6162                if ( labeledBlock ) {
    6263                        Label brkLabel = generator->newLabel("blockBreak", cmpndStmt);
    … …  
    6566
    6667                // a child statement may set the break label - if they do, attach it to the next statement
    67                 std::list< Statement * > &kids = cmpndStmt->get_kids();
     68                std::list< Statement * > &kids = cmpndStmt->kids;
    6869                fixBlock( kids );
    6970
    … …  
    7576                        enclosingControlStructures.pop_back();
    7677                } // if
    77 
    78                 return cmpndStmt;
    79         }
    80 
    81         template< typename LoopClass >
    82         Statement *MLEMutator::handleLoopStmt( LoopClass *loopStmt ) {
    83                 // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
    84                 // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
    85                 // loops
    86                 Label brkLabel = generator->newLabel("loopBreak", loopStmt);
    87                 Label contLabel = generator->newLabel("loopContinue", loopStmt);
    88                 enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
    89                 loopStmt->set_body ( loopStmt->get_body()->acceptMutator( *this ) );
    90 
    91                 assert( ! enclosingControlStructures.empty() );
    92                 Entry &e = enclosingControlStructures.back();
    93                 // sanity check that the enclosing loops have been popped correctly
    94                 assert ( e == loopStmt );
    95 
    96                 // this will take the necessary steps to add definitions of the previous two labels, if they are used.
    97                 loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
    98                 enclosingControlStructures.pop_back();
    99 
    100                 return loopStmt;
    101         }
    102 
    103         Statement *MLEMutator::mutate( CaseStmt *caseStmt ) {
    104                 caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
    105                 fixBlock( caseStmt->get_statements() );
    106 
    107                 return caseStmt;
    108         }
    109 
    110         template< typename IfClass >
    111         Statement *MLEMutator::handleIfStmt( IfClass *ifStmt ) {
    112                 // generate a label for breaking out of a labeled if
    113                 bool labeledBlock = !(ifStmt->get_labels().empty());
    114                 if ( labeledBlock ) {
    115                         Label brkLabel = generator->newLabel("blockBreak", ifStmt);
    116                         enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
    117                 } // if
    118 
    119                 Parent::mutate( ifStmt );
    120 
    121                 if ( labeledBlock ) {
    122                         if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
    123                                 set_breakLabel( enclosingControlStructures.back().useBreakExit() );
    124                         } // if
    125                         enclosingControlStructures.pop_back();
    126                 } // if
    127                 return ifStmt;
    128         }
    129 
    130         template< typename SwitchClass >
    131         Statement *MLEMutator::handleSwitchStmt( SwitchClass *switchStmt ) {
    132                 // generate a label for breaking out of a labeled switch
    133                 Label brkLabel = generator->newLabel("switchBreak", switchStmt);
    134                 enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
    135                 mutateAll( switchStmt->get_statements(), *this );
    136 
    137                 Entry &e = enclosingControlStructures.back();
    138                 assert ( e == switchStmt );
    139 
    140                 // only generate break label if labeled break is used
    141                 if ( e.isBreakUsed() ) {
    142                         // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a
    143                         // switch should be CastStmts), append the exit label + break to the last case statement; create a default
    144                         // case if there are no cases
    145                         std::list< Statement * > &statements = switchStmt->get_statements();
    146                         if ( statements.empty() ) {
    147                                 statements.push_back( CaseStmt::makeDefault() );
    148                         } // if
    149 
    150                         if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
    151                                 Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
    152                                 stmt->labels.push_back( brkLabel );
    153                                 c->get_statements().push_back( stmt );
    154                         } else assert(0); // as of this point, all statements of a switch are still CaseStmts
    155                 } // if
    156 
    157                 assert ( enclosingControlStructures.back() == switchStmt );
    158                 enclosingControlStructures.pop_back();
    159                 return switchStmt;
    160         }
     78        }
     79
    16180
    16281        void addUnused( Statement * stmt, const Label & originalTarget ) {
    … …  
    17998
    18099
    181         Statement *MLEMutator::mutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
    182                 std::string originalTarget = branchStmt->get_originalTarget();
     100        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
     101                std::string originalTarget = branchStmt->originalTarget;
    183102
    184103                std::list< Entry >::reverse_iterator targetEntry;
    … …  
    215134                // branch error checks, get the appropriate label name and create a goto
    216135                Label exitLabel;
    217                 switch ( branchStmt->get_type() ) {
     136                switch ( branchStmt->type ) {
    218137                  case BranchStmt::Break:
    219138                                assert( targetEntry->useBreakExit() != "");
    … …  
    229148
    230149                // add unused attribute to label to silence warnings
    231                 addUnused( targetEntry->get_controlStructure(), branchStmt->get_originalTarget() );
     150                addUnused( targetEntry->get_controlStructure(), branchStmt->originalTarget );
    232151
    233152                // transform break/continue statements into goto to simplify later handling of branches
    … …  
    260179        }
    261180
    262         Statement *MLEMutator::mutate( WhileStmt *whileStmt ) {
    263                 return handleLoopStmt( whileStmt );
    264         }
    265 
    266         Statement *MLEMutator::mutate( ForStmt *forStmt ) {
    267                 return handleLoopStmt( forStmt );
    268         }
    269 
    270         Statement *MLEMutator::mutate( IfStmt *ifStmt ) {
    271                 return handleIfStmt( ifStmt );
    272         }
    273 
    274         Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) {
    275                 return handleSwitchStmt( switchStmt );
     181        template< typename LoopClass >
     182        void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
     183                // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
     184                // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
     185                // loops
     186                Label brkLabel = generator->newLabel("loopBreak", loopStmt);
     187                Label contLabel = generator->newLabel("loopContinue", loopStmt);
     188                enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
     189        }
     190
     191        template< typename LoopClass >
     192        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
     193                assert( ! enclosingControlStructures.empty() );
     194                Entry &e = enclosingControlStructures.back();
     195                // sanity check that the enclosing loops have been popped correctly
     196                assert ( e == loopStmt );
     197
     198                // this will take the necessary steps to add definitions of the previous two labels, if they are used.
     199                loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
     200                enclosingControlStructures.pop_back();
     201                return loopStmt;
     202        }
     203
     204        void MLEMutator::premutate( WhileStmt * whileStmt ) {
     205                return prehandleLoopStmt( whileStmt );
     206        }
     207
     208        void MLEMutator::premutate( ForStmt * forStmt ) {
     209                return prehandleLoopStmt( forStmt );
     210        }
     211
     212        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
     213                return posthandleLoopStmt( whileStmt );
     214        }
     215
     216        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
     217                return posthandleLoopStmt( forStmt );
     218        }
     219
     220        void MLEMutator::premutate( IfStmt * ifStmt ) {
     221                // generate a label for breaking out of a labeled if
     222                bool labeledBlock = !(ifStmt->get_labels().empty());
     223                if ( labeledBlock ) {
     224                        Label brkLabel = generator->newLabel("blockBreak", ifStmt);
     225                        enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
     226                } // if
     227        }
     228
     229        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
     230                bool labeledBlock = !(ifStmt->get_labels().empty());
     231                if ( labeledBlock ) {
     232                        if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
     233                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
     234                        } // if
     235                        enclosingControlStructures.pop_back();
     236                } // if
     237                return ifStmt;
     238        }
     239
     240        void MLEMutator::premutate( CaseStmt *caseStmt ) {
     241                visit_children = false;
     242                caseStmt->condition = maybeMutate( caseStmt->condition, *visitor );
     243                fixBlock( caseStmt->stmts );
     244        }
     245
     246        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
     247                // generate a label for breaking out of a labeled switch
     248                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
     249                enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
     250        }
     251
     252        Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) {
     253                Entry &e = enclosingControlStructures.back();
     254                assert ( e == switchStmt );
     255
     256                // only generate break label if labeled break is used
     257                if ( e.isBreakUsed() ) {
     258                        // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a
     259                        // switch should be CastStmts), append the exit label + break to the last case statement; create a default
     260                        // case if there are no cases
     261                        std::list< Statement * > &statements = switchStmt->statements;
     262                        if ( statements.empty() ) {
     263                                statements.push_back( CaseStmt::makeDefault() );
     264                        } // if
     265
     266                        if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
     267                                Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
     268                                stmt->labels.push_back( e.useBreakExit() );
     269                                c->stmts.push_back( stmt );
     270                        } else assert(0); // as of this point, all statements of a switch are still CaseStmts
     271                } // if
     272
     273                assert ( enclosingControlStructures.back() == switchStmt );
     274                enclosingControlStructures.pop_back();
     275                return switchStmt;
    276276        }
    277277} // namespace ControlStruct

  • src/ControlStruct/MLEMutator.h

    rb158d8f rb6838214  
    2020#include <string>                  // for string
    2121
     22#include "Common/PassVisitor.h"
    2223#include "Common/SemanticError.h"  // for SemanticError
    2324#include "SynTree/Label.h"         // for Label
    … …  
    2627
    2728namespace ControlStruct {
    28 class LabelGenerator;
     29        class LabelGenerator;
    2930
    30         class MLEMutator : public Mutator {
     31        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting {
    3132                class Entry;
    3233
    33                 typedef Mutator Parent;
    3434          public:
    3535                MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
    3636                ~MLEMutator();
    3737
    38                 virtual CompoundStmt *mutate( CompoundStmt *cmpndStmt ) override;
    39                 virtual Statement *mutate( WhileStmt *whileStmt ) override;
    40                 virtual Statement *mutate( ForStmt *forStmt ) override;
    41                 virtual Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError ) override;
    42                 virtual Statement *mutate( CaseStmt *caseStmt ) override;
    43                 virtual Statement *mutate( IfStmt *ifStmt ) override;
    44                 virtual Statement *mutate( SwitchStmt *switchStmt ) override;
     38                void premutate( CompoundStmt *cmpndStmt );
     39                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticError );
     40                void premutate( WhileStmt *whileStmt );
     41                Statement * postmutate( WhileStmt *whileStmt );
     42                void premutate( ForStmt *forStmt );
     43                Statement * postmutate( ForStmt *forStmt );
     44                void premutate( CaseStmt *caseStmt );
     45                void premutate( IfStmt *ifStmt );
     46                Statement * postmutate( IfStmt *ifStmt );
     47                void premutate( SwitchStmt *switchStmt );
     48                Statement * postmutate( SwitchStmt *switchStmt );
    4549
    4650                Statement *mutateLoop( Statement *bodyLoop, Entry &e );
    … …  
    5458                                loop( _loop ), breakExit( _breakExit ), contExit( _contExit ), breakUsed(false), contUsed(false) {}
    5559
    56                         bool operator==( const Statement *stmt ) { return ( loop == stmt ); }
    57                         bool operator!=( const Statement *stmt ) { return ( loop != stmt ); }
     60                        bool operator==( const Statement *stmt ) { return loop == stmt; }
     61                        bool operator!=( const Statement *stmt ) { return loop != stmt; }
    5862
    59                         bool operator==( const Entry &other ) { return ( loop == other.get_controlStructure() ); }
     63                        bool operator==( const Entry &other ) { return loop == other.get_controlStructure(); }
    6064
    6165                        Statement *get_controlStructure() const { return loop; }
    … …  
    7882
    7983                template< typename LoopClass >
    80                 Statement *handleLoopStmt( LoopClass *loopStmt );
     84                void prehandleLoopStmt( LoopClass * loopStmt );
    8185
    82                 template< typename IfClass >
    83                 Statement *handleIfStmt( IfClass *switchStmt );
    84 
    85                 template< typename SwitchClass >
    86                 Statement *handleSwitchStmt( SwitchClass *switchStmt );
     86                template< typename LoopClass >
     87                Statement * posthandleLoopStmt( LoopClass * loopStmt );
    8788
    8889                void fixBlock( std::list< Statement * > &kids );

  • src/GenPoly/Box.cc

    rb158d8f rb6838214  
    302302        Expression *makeOp( const std::string &name, Expression *arg ) {
    303303                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
    304                 expr->get_args().push_back( arg );
     304                expr->args.push_back( arg );
    305305                return expr;
    306306        }
    … …  
    309309        Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
    310310                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
    311                 expr->get_args().push_back( lhs );
    312                 expr->get_args().push_back( rhs );
     311                expr->args.push_back( lhs );
     312                expr->args.push_back( rhs );
    313313                return expr;
    314314        }
    … …  
    316316        /// Returns the dereference of a local pointer variable
    317317        Expression *derefVar( ObjectDecl *var ) {
    318                 return makeOp( "*?", new VariableExpr( var ) );
     318                return UntypedExpr::createDeref( new VariableExpr( var ) );
    319319        }
    320320
    … …  
    831831                                if ( ! isPolyType( arg->get_type() ) ) {
    832832                                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    833                                         deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
    834                                         deref->set_result( arg->get_type()->clone() );
     833                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
     834                                        deref->result = arg->get_type()->clone();
     835                                        deref->result->set_lvalue( true );
    835836                                        return deref;
    836837                                } // if

  • src/GenPoly/Lvalue.cc

    rb158d8f rb6838214  
    4747                        if ( SymTab::dereferenceOperator ) {
    4848                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
    49                                 deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
    50                                 Type * base = InitTweak::getPointerBase( arg->get_result() );
    51                                 assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
     49                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
     50                                Type * base = InitTweak::getPointerBase( arg->result );
     51                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
    5252                                ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
    53                                 delete ret->get_result();
    54                                 ret->set_result( base->clone() );
    55                                 ret->get_result()->set_lvalue( true );
     53                                delete ret->result;
     54                                ret->result = base->clone();
     55                                ret->result->set_lvalue( true );
    5656                                return ret;
    5757                        } else {
    … …  
    308308                                        int diff = depth1-depth2;
    309309                                        if ( diff == 0 ) {
     310                                                // conversion between references of the same depth
    310311                                                assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
    311312                                                PRINT( std::cerr << castExpr << std::endl; )
    312313                                                return castExpr;
    313314                                        } else if ( diff < 0 ) {
    314                                                 Expression * ret = castExpr->get_arg();
     315                                                // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
     316                                                Expression * ret = castExpr->arg;
    315317                                                for ( int i = 0; i < diff; ++i ) {
    316318                                                        ret = mkDeref( ret );
    317319                                                }
    318                                                 ret->set_env( castExpr->get_env() );
    319                                                 delete ret->get_result();
    320                                                 ret->set_result( castExpr->get_result() );
    321                                                 castExpr->set_env( nullptr );
    322                                                 castExpr->set_arg( nullptr );
    323                                                 castExpr->set_result( nullptr );
     320                                                ret->env = castExpr->env;
     321                                                delete ret->result;
     322                                                ret->result = castExpr->result;
     323                                                ret->result->set_lvalue( true ); // ensure result is lvalue
     324                                                castExpr->env = nullptr;
     325                                                castExpr->arg = nullptr;
     326                                                castExpr->result = nullptr;
    324327                                                delete castExpr;
    325328                                                return ret;
    326329                                        } else if ( diff > 0 ) {
    327                                                 Expression * ret = castExpr->get_arg();
     330                                                // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
     331                                                Expression * ret = castExpr->arg;
    328332                                                for ( int i = 0; i < diff; ++i ) {
    329333                                                        ret = new AddressExpr( ret );
    330334                                                }
    331                                                 ret->set_env( castExpr->get_env() );
    332                                                 delete ret->get_result();
    333                                                 ret->set_result( castExpr->get_result() );
    334                                                 castExpr->set_env( nullptr );
    335                                                 castExpr->set_arg( nullptr );
    336                                                 castExpr->set_result( nullptr );
     335                                                ret->env = castExpr->env;
     336                                                delete ret->result;
     337                                                ret->result = castExpr->result;
     338                                                castExpr->env = nullptr;
     339                                                castExpr->arg = nullptr;
     340                                                castExpr->result = nullptr;
    337341                                                delete castExpr;
    338342                                                return ret;
    … …  
    342346                                        PRINT( std::cerr << castExpr << std::endl; )
    343347                                        return castExpr;
    344                                 } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
     348                                } else if ( castExpr->arg->result->get_lvalue() ) {
    345349                                        // conversion from lvalue to reference
    346350                                        // xxx - keep cast, but turn into pointer cast??
    … …  
    348352                                        PRINT(
    349353                                                std::cerr << "convert lvalue to reference -- &" << std::endl;
    350                                                 std::cerr << castExpr->get_arg() << std::endl;
     354                                                std::cerr << castExpr->arg << std::endl;
    351355                                        )
    352                                         AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
    353                                         if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
     356                                        AddressExpr * ret = new AddressExpr( castExpr->arg );
     357                                        if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
    354358                                                // must keep cast if cast-to type is different from the actual type
    355                                                 castExpr->set_arg( ret );
     359                                                castExpr->arg = ret;
    356360                                                return castExpr;
    357361                                        }
    358                                         ret->set_env( castExpr->get_env() );
    359                                         delete ret->get_result();
    360                                         ret->set_result( castExpr->get_result() );
    361                                         castExpr->set_env( nullptr );
    362                                         castExpr->set_arg( nullptr );
    363                                         castExpr->set_result( nullptr );
     362                                        ret->env = castExpr->env;
     363                                        delete ret->result;
     364                                        ret->result = castExpr->result;
     365                                        castExpr->env = nullptr;
     366                                        castExpr->arg = nullptr;
     367                                        castExpr->result = nullptr;
    364368                                        delete castExpr;
    365369                                        return ret;
    … …  
    368372                                }
    369373                                assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
    370                         } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
     374                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
    371375                                (void)refType;
    372376                                // conversion from reference to rvalue
    … …  
    375379                                        std::cerr << "was = " << castExpr << std::endl;
    376380                                )
    377                                 Expression * ret = castExpr->get_arg();
    378                                 TypeSubstitution * env = castExpr->get_env();
     381                                Expression * ret = castExpr->arg;
     382                                TypeSubstitution * env = castExpr->env;
    379383                                castExpr->set_env( nullptr );
    380384                                if ( ! isIntrinsicReference( ret ) ) {
    … …  
    382386                                        ret = mkDeref( ret );
    383387                                }
    384                                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
     388                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
    385389                                        // can remove cast if types are compatible, changing expression type to value type
    386                                         ret->set_result( castExpr->get_result()->clone() );
    387                                         castExpr->set_arg( nullptr );
     390                                        ret->result = castExpr->result->clone();
     391                                        ret->result->set_lvalue( true );  // ensure result is lvalue
     392                                        castExpr->arg = nullptr;
    388393                                        delete castExpr;
    389394                                } else {
    390395                                        // must keep cast if types are different
    391                                         castExpr->set_arg( ret );
     396                                        castExpr->arg = ret;
    392397                                        ret = castExpr;
    393398                                }

  • src/GenPoly/ScrubTyVars.cc

    rb158d8f rb6838214  
    2525
    2626namespace GenPoly {
    27         Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
     27        Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) {
    2828                if ( ! tyVars ) {
    2929                        if ( typeInst->get_isFtype() ) {
    … …  
    3131                                return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
    3232                        } else {
    33                                 PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
     33                                PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
    3434                                delete typeInst;
    3535                                return ret;
    … …  
    3737                }
    3838
    39                 TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() );
     39                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name );
    4040                if ( tyVar != tyVars->end() ) {
    4141                        switch ( tyVar->second.kind ) {
    … …  
    4343                          case TypeDecl::Ttype:
    4444                                {
    45                                         PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
     45                                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
    4646                                        delete typeInst;
    4747                                        return ret;
    … …  
    5555        }
    5656
    57         Type * ScrubTyVars::mutateAggregateType( Type *ty ) {
     57        Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
    5858                if ( shouldScrub( ty ) ) {
    59                         PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
     59                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
    6060                        delete ty;
    6161                        return ret;
    … …  
    6464        }
    6565
    66         Type * ScrubTyVars::mutate( StructInstType *structInst ) {
     66        Type * ScrubTyVars::postmutate( StructInstType * structInst ) {
    6767                return mutateAggregateType( structInst );
    6868        }
    6969
    70         Type * ScrubTyVars::mutate( UnionInstType *unionInst ) {
     70        Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) {
    7171                return mutateAggregateType( unionInst );
    7272        }
    7373
    74         Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
     74        void ScrubTyVars::primeBaseScrub( Type * type ) {
     75                // need to determine whether type needs to be scrubbed to determine whether
     76                // automatic recursion is necessary
     77                if ( Type * t = shouldScrub( type ) ) {
     78                        visit_children = false;
     79                        GuardValue( dynType );
     80                        dynType = t;
     81                }
     82        }
     83
     84        Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) {
    7585                // sizeof( T ) => _sizeof_T parameter, which is the size of T
    76                 if ( Type *dynType = shouldScrub( szeof->get_type() ) ) {
     86                if ( dynType ) {
    7787                        Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) );
    7888                        return expr;
    79                 } else {
    80                         return Mutator::mutate( szeof );
    8189                } // if
     90                return szeof;
    8291        }
    8392
    84         Expression * ScrubTyVars::mutate( AlignofExpr *algnof ) {
     93        Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) {
    8594                // alignof( T ) => _alignof_T parameter, which is the alignment of T
    86                 if ( Type *dynType = shouldScrub( algnof->get_type() ) ) {
     95                if ( dynType ) {
    8796                        Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) );
    8897                        return expr;
    89                 } else {
    90                         return Mutator::mutate( algnof );
    9198                } // if
     99                return algnof;
    92100        }
    93101
    94         Type * ScrubTyVars::mutate( PointerType *pointer ) {
    95 //              // special case of shouldScrub that takes all TypeInstType pointer bases, even if they're not dynamic
    96 //              Type *base = pointer->get_base();
    97 //              Type *dynType = 0;
    98 //              if ( dynamicOnly ) {
    99 //                      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( base ) ) {
    100 //                              if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) { dynType = typeInst; }
    101 //                      } else {
    102 //                              dynType = isDynType( base, tyVars );
    103 //                      }
    104 //              } else {
    105 //                      dynType = isPolyType( base, tyVars );
    106 //              }
    107 //              if ( dynType ) {
    108                 if ( Type *dynType = shouldScrub( pointer->get_base() ) ) {
    109                         Type *ret = dynType->acceptMutator( *this );
     102        Type * ScrubTyVars::postmutate( PointerType * pointer ) {
     103                if ( dynType ) {
     104                        Type * ret = dynType->acceptMutator( *visitor );
    110105                        ret->get_qualifiers() |= pointer->get_qualifiers();
    111                         pointer->set_base( 0 );
     106                        pointer->base = nullptr;
    112107                        delete pointer;
    113108                        return ret;
    114109                }
    115                 return Mutator::mutate( pointer );
     110                return pointer;
    116111        }
    117112} // namespace GenPoly

  • src/GenPoly/ScrubTyVars.h

    rb158d8f rb6838214  
    1818#include <cassert>            // for assert
    1919
     20#include "Common/PassVisitor.h"
    2021#include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
    2122#include "SynTree/Mutator.h"  // for Mutator
    … …  
    2728
    2829namespace GenPoly {
    29         class ScrubTyVars : public Mutator {
     30        struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards {
    3031                /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
    3132                enum ScrubMode { FromMap, DynamicFromMap, All };
    … …  
    5152                static SynTreeClass *scrubAll( SynTreeClass *target );
    5253
    53                 virtual Type* mutate( TypeInstType *typeInst );
    54                 virtual Type* mutate( StructInstType *structInst );
    55                 virtual Type* mutate( UnionInstType *unionInst );
    56                 virtual Expression* mutate( SizeofExpr *szeof );
    57                 virtual Expression* mutate( AlignofExpr *algnof );
    58                 virtual Type* mutate( PointerType *pointer );
     54                /// determine if children should be visited based on whether base type should be scrubbed.
     55                void primeBaseScrub( Type * );
     56
     57                void premutate( TypeInstType * ) { visit_children = false; }
     58                void premutate( StructInstType * ) { visit_children = false; }
     59                void premutate( UnionInstType * ) { visit_children = false; }
     60                void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); }
     61                void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); }
     62                void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); }
     63
     64                Type * postmutate( TypeInstType * typeInst );
     65                Type * postmutate( StructInstType * structInst );
     66                Type * postmutate( UnionInstType * unionInst );
     67                Expression * postmutate( SizeofExpr * szeof );
     68                Expression * postmutate( AlignofExpr * algnof );
     69                Type * postmutate( PointerType * pointer );
    5970
    6071          private:
    … …  
    7586                const TyVarMap *tyVars;  ///< Type variables to scrub
    7687                ScrubMode mode;          ///< which type variables to scrub? [FromMap]
     88
     89                Type * dynType = nullptr; ///< result of shouldScrub
    7790        };
    7891
    7992        template< typename SynTreeClass >
    8093        SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
    81                 ScrubTyVars scrubber( tyVars );
     94                PassVisitor<ScrubTyVars> scrubber( tyVars );
    8295                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
    8396        }
    … …  
    8598        template< typename SynTreeClass >
    8699        SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
    87                 ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap );
     100                PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap );
    88101                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
    89102        }
    … …  
    91104        template< typename SynTreeClass >
    92105        SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
    93                 ScrubTyVars scrubber;
     106                PassVisitor<ScrubTyVars> scrubber;
    94107                return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
    95108        }

  • src/InitTweak/FixInit.cc

    rb158d8f rb6838214  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FixInit.h --
     7// FixInit.cc --
    88//
    99// Author           : Rob Schluntz
    … …  
    197197                };
    198198
    199                 struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
     199                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer, public WithVisitorRef<GenStructMemberCalls> {
    200200                        /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
    201201                        /// for any member that is missing a corresponding ctor/dtor call.
    … …  
    203203                        static void generate( std::list< Declaration * > & translationUnit );
    204204
    205                         void previsit( FunctionDecl * funcDecl );
    206                         void postvisit( FunctionDecl * funcDecl );
    207 
    208                         void previsit( MemberExpr * memberExpr );
    209                         void previsit( ApplicationExpr * appExpr );
     205                        void premutate( FunctionDecl * funcDecl );
     206                        DeclarationWithType * postmutate( FunctionDecl * funcDecl );
     207
     208                        void premutate( MemberExpr * memberExpr );
     209                        void premutate( ApplicationExpr * appExpr );
     210
     211                        /// Note: this post mutate used to be in a separate visitor. If this pass breaks, one place to examine is whether it is
     212                        /// okay for this part of the recursion to occur alongside the rest.
     213                        Expression * postmutate( UntypedExpr * expr );
    210214
    211215                        SemanticError errors;
    … …  
    220224                        bool isCtor = false; // true if current function is a constructor
    221225                        StructDecl * structDecl = nullptr;
    222                 };
    223 
    224                 // very simple resolver-like mutator class - used to
    225                 // resolve UntypedExprs that are found within newly
    226                 // generated constructor/destructor calls
    227                 class MutatingResolver final : public Mutator {
    228                   public:
    229                         MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
    230 
    231                         using Mutator::mutate;
    232                         virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
    233                         virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
    234 
    235                   private:
    236                         SymTab::Indexer & indexer;
    237226                };
    238227
    … …  
    315304                void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
    316305                        PassVisitor<GenStructMemberCalls> warner;
    317                         acceptAll( translationUnit, warner );
     306                        mutateAll( translationUnit, warner );
    318307                }
    319308
    … …  
    365354                        // arrays are not copy constructed, so this should always be an ExprStmt
    366355                        ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
    367                         ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
     356                        assertf( stmt, "ResolveCopyCtors: genCtorDtor returned nullptr: %s / %s / %s", fname.c_str(), toString( var ).c_str(), toString( cpArg ).c_str() );
     357                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->callStmt );
    368358                        Expression * resolved = exprStmt->expr;
    369359                        exprStmt->expr = nullptr; // take ownership of expr
    … …  
    382372                        } // if
    383373                        delete stmt;
     374                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
     375                                // fix newly generated StmtExpr
     376                                postvisit( assign->stmtExpr );
     377                        }
    384378                        return resolved;
    385379                }
    … …  
    475469                                static UniqueName retNamer("_tmp_stmtexpr_ret");
    476470
    477                                 // create variable that will hold the result of the stmt expr
    478471                                result = result->clone();
    479472                                env->apply( result );
     473                                if ( ! InitTweak::isConstructable( result ) ) {
     474                                        delete result;
     475                                        return;
     476                                }
     477
     478                                // create variable that will hold the result of the stmt expr
    480479                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
    481                                 ret->get_type()->set_const( false );
    482                                 stmtExpr->get_returnDecls().push_front( ret );
     480                                ret->type->set_const( false );
     481                                stmtExpr->returnDecls.push_front( ret );
    483482
    484483                                // must have a non-empty body, otherwise it wouldn't have a result
    485                                 CompoundStmt * body = stmtExpr->get_statements();
     484                                CompoundStmt * body = stmtExpr->statements;
    486485                                assert( ! body->get_kids().empty() );
    487486                                // must be an ExprStmt, otherwise it wouldn't have a result
    488487                                ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
    489                                 last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
    490 
    491                                 stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
     488                                last->expr = makeCtorDtor( "?{}", ret, last->get_expr() );
     489
     490                                stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) );
    492491                        } // if
    493492                }
    … …  
    590589                        // to the outer context, rather than inside of the statement expression.
    591590                        visit_children = false;
    592                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
     591                        std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
    593592                        for ( Statement *& stmt : stmts ) {
    594593                                stmt = stmt->acceptMutator( *visitor );
    595594                        } // for
    596                         assert( stmtExpr->get_result() );
    597                         Type * result = stmtExpr->get_result();
     595                        assert( stmtExpr->result );
     596                        Type * result = stmtExpr->result;
    598597                        if ( ! result->isVoid() ) {
    599                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
     598                                for ( ObjectDecl * obj : stmtExpr->returnDecls ) {
    600599                                        stmtsToAddBefore.push_back( new DeclStmt( obj ) );
    601600                                } // for
    602601                                // add destructors after current statement
    603                                 for ( Expression * dtor : stmtExpr->get_dtors() ) {
     602                                for ( Expression * dtor : stmtExpr->dtors ) {
    604603                                        stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
    605604                                } // for
    606605                                // must have a non-empty body, otherwise it wouldn't have a result
    607606                                assert( ! stmts.empty() );
    608                                 assert( ! stmtExpr->get_returnDecls().empty() );
    609                                 stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
    610                                 stmtExpr->get_returnDecls().clear();
    611                                 stmtExpr->get_dtors().clear();
    612                         }
    613                         assert( stmtExpr->get_returnDecls().empty() );
    614                         assert( stmtExpr->get_dtors().empty() );
     607                                assertf( ! stmtExpr->returnDecls.empty() || stmtExpr->dtors.empty(), "StmtExpr returns non-void, but no return decls: %s", toString( stmtExpr ).c_str() );
     608                                // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
     609                                if ( ! stmtExpr->returnDecls.empty() ) {
     610                                        stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->returnDecls.front() ) ) );
     611                                }
     612                                stmtExpr->returnDecls.clear();
     613                                stmtExpr->dtors.clear();
     614                        }
     615                        assert( stmtExpr->returnDecls.empty() );
     616                        assert( stmtExpr->dtors.empty() );
    615617                }
    616618
    … …  
    937939                }
    938940
    939                 void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
     941                void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) {
    940942                        GuardValue( function );
    941943                        GuardValue( unhandled );
    … …  
    971973                }
    972974
    973                 void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
     975                DeclarationWithType * GenStructMemberCalls::postmutate( FunctionDecl * funcDecl ) {
    974976                        // remove the unhandled objects from usedUninit, because a call is inserted
    975977                        // to handle them - only objects that are later constructed are used uninitialized.
    … …  
    10251027                                                Statement * callStmt = stmt.front();
    10261028
    1027                                                 MutatingResolver resolver( indexer );
    10281029                                                try {
    1029                                                         callStmt->acceptMutator( resolver );
     1030                                                        callStmt->acceptMutator( *visitor );
    10301031                                                        if ( isCtor ) {
    10311032                                                                function->get_statements()->push_front( callStmt );
    … …  
    10431044                                throw errors;
    10441045                        }
     1046                        return funcDecl;
    10451047                }
    10461048
    … …  
    10681070                }
    10691071
    1070                 void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
     1072                void GenStructMemberCalls::premutate( ApplicationExpr * appExpr ) {
    10711073                        if ( ! checkWarnings( function ) ) {
    10721074                                visit_children = false;
    … …  
    10931095                }
    10941096
    1095                 void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
     1097                void GenStructMemberCalls::premutate( MemberExpr * memberExpr ) {
    10961098                        if ( ! checkWarnings( function ) || ! isCtor ) {
    10971099                                visit_children = false;
    … …  
    11211123                }
    11221124
    1123                 DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
    1124                         // add object to the indexer assumes that there will be no name collisions
    1125                         // in generated code. If this changes, add mutate methods for entities with
    1126                         // scope and call {enter,leave}Scope explicitly.
    1127                         indexer.addId( objectDecl );
    1128                         return objectDecl;
    1129                 }
    1130 
    1131                 Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
     1125                Expression * GenStructMemberCalls::postmutate( UntypedExpr * untypedExpr ) {
    11321126                        Expression * newExpr = untypedExpr;
    11331127                        ResolvExpr::findVoidExpression( newExpr, indexer );

  • src/InitTweak/GenInit.cc

    rb158d8f rb6838214  
    3030#include "InitTweak.h"             // for isConstExpr, InitExpander, checkIn...
    3131#include "Parser/LinkageSpec.h"    // for isOverridable, C
     32#include "ResolvExpr/Resolver.h"
    3233#include "SymTab/Autogen.h"        // for genImplicitCall, SizeType
    3334#include "SymTab/Mangler.h"        // for Mangler
    … …  
    4041#include "SynTree/Type.h"          // for Type, ArrayType, Type::Qualifiers
    4142#include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
     43#include "Tuples/Tuples.h"         // for maybeImpure
    4244
    4345namespace InitTweak {
    … …  
    8991        };
    9092
    91         struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
     93        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards, public WithIndexer {
    9294                /// hoist dimension from array types in object declaration so that it uses a single
    9395                /// const variable of type size_t, so that side effecting array dimensions are only
    … …  
    104106                void premutate( FunctionType * ) { visit_children = false; }
    105107
     108                // need this so that enumerators are added to the indexer, due to premutate(AggregateDecl *)
     109                void premutate( EnumDecl * ) {}
     110
    106111                void hoist( Type * type );
    107112
    … …  
    135140                                if ( varExpr->var == retVal ) return;
    136141                        }
    137                         stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
     142                        Statement * stmt = genCtorDtor( "?{}", retVal, returnStmt->expr );
     143                        assertf( stmt, "ReturnFixer: genCtorDtor returned nullptr: %s / %s", toString( retVal ).c_str(), toString( returnStmt->expr ).c_str() );
     144                        stmtsToAddBefore.push_back( stmt );
    138145
    139146                        // return the retVal object
    … …  
    178185                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
    179186
    180                         // don't need to hoist dimension if it's a constexpr - only need to if there's potential for side effects.
    181                         if ( isConstExpr( arrayType->get_dimension() ) ) return;
     187                        // need to resolve array dimensions in order to accurately determine if constexpr
     188                        ResolvExpr::findSingleExpression( arrayType->dimension, SymTab::SizeType->clone(), indexer );
     189                        // array is variable-length when the dimension is not constexpr
     190                        arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
     191                        // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
     192                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
    182193
    183194                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
    … …  
    194205        void HoistArrayDimension::premutate( FunctionDecl * ) {
    195206                GuardValue( inFunction );
     207                inFunction = true;
    196208        }
    197209
    … …  
    220232                Type * type = objDecl->get_type();
    221233                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
     234                        // must always construct VLAs with an initializer, since this is an error in C
     235                        if ( at->isVarLen && objDecl->init ) return true;
    222236                        type = at->get_base();
    223237                }

  • src/InitTweak/InitTweak.cc

    rb158d8f rb6838214  
    564564                void previsit( ConstantExpr * ) {}
    565565
     566                void previsit( VariableExpr * varExpr ) {
     567                        visit_children = false;
     568
     569                        if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( varExpr->result ) ) {
     570                                long long int value;
     571                                if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
     572                                        // enumerators are const expr
     573                                        return;
     574                                }
     575                        }
     576                        isConstExpr = false;
     577                }
     578
    566579                bool isConstExpr = true;
    567580        };

  • src/Parser/DeclarationNode.cc

    rb158d8f rb6838214  
    343343        DeclarationNode * newnode = new DeclarationNode;
    344344        newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
     345        if ( kind == OperKinds::And ) {
     346                // T && is parsed as 'And' operator rather than two references => add a second reference type
     347                TypeData * td = new TypeData( TypeData::Reference );
     348                td->base = newnode->type;
     349                newnode->type = td;
     350        }
    345351        if ( qualifiers ) {
    346352                return newnode->addQualifiers( qualifiers );

  • src/Parser/parser.yy

    rb158d8f rb6838214  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Nov 27 17:23:35 2017
    13 // Update Count     : 2992
     12// Last Modified On : Thu Dec 21 11:32:56 2017
     13// Update Count     : 2996
    1414//
    1515
    … …  
    317317%type<decl> cfa_typedef_declaration cfa_variable_declaration cfa_variable_specifier
    318318
    319 %type<decl> c_declaration
     319%type<decl> c_declaration static_assert
    320320%type<decl> KR_function_declarator KR_function_no_ptr KR_function_ptr KR_function_array
    321321%type<decl> KR_declaration_list KR_declaration_list_opt
    … …  
    835835        | exception_statement
    836836        | asm_statement
     837        ;
    837838
    838839labeled_statement:
    … …  
    12821283        c_declaration pop ';'
    12831284        | cfa_declaration pop ';'                                                       // CFA
    1284         | STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
     1285        | static_assert
     1286        ;
     1287
     1288static_assert:
     1289        STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
    12851290                { throw SemanticError("Static assert is currently unimplemented."); $$ = nullptr; }     // FIX ME
    1286         ;
    12871291
    12881292// C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
    … …  
    18901894                        $$ = distAttr( $2, $3 );
    18911895                }
     1896        | static_assert
    18921897        ;
    18931898

  • src/ResolvExpr/AlternativeFinder.cc

    rb158d8f rb6838214  
    6060
    6161namespace ResolvExpr {
     62        struct AlternativeFinder::Finder : public WithShortCircuiting {
     63                Finder( AlternativeFinder & altFinder ) : altFinder( altFinder ), indexer( altFinder.indexer ), alternatives( altFinder.alternatives ), env( altFinder.env ), targetType( altFinder.targetType )  {}
     64
     65                void previsit( BaseSyntaxNode * ) { visit_children = false; }
     66
     67                void postvisit( ApplicationExpr * applicationExpr );
     68                void postvisit( UntypedExpr * untypedExpr );
     69                void postvisit( AddressExpr * addressExpr );
     70                void postvisit( LabelAddressExpr * labelExpr );
     71                void postvisit( CastExpr * castExpr );
     72                void postvisit( VirtualCastExpr * castExpr );
     73                void postvisit( UntypedMemberExpr * memberExpr );
     74                void postvisit( MemberExpr * memberExpr );
     75                void postvisit( NameExpr * variableExpr );
     76                void postvisit( VariableExpr * variableExpr );
     77                void postvisit( ConstantExpr * constantExpr );
     78                void postvisit( SizeofExpr * sizeofExpr );
     79                void postvisit( AlignofExpr * alignofExpr );
     80                void postvisit( UntypedOffsetofExpr * offsetofExpr );
     81                void postvisit( OffsetofExpr * offsetofExpr );
     82                void postvisit( OffsetPackExpr * offsetPackExpr );
     83                void postvisit( AttrExpr * attrExpr );
     84                void postvisit( LogicalExpr * logicalExpr );
     85                void postvisit( ConditionalExpr * conditionalExpr );
     86                void postvisit( CommaExpr * commaExpr );
     87                void postvisit( ImplicitCopyCtorExpr  * impCpCtorExpr );
     88                void postvisit( ConstructorExpr  * ctorExpr );
     89                void postvisit( RangeExpr  * rangeExpr );
     90                void postvisit( UntypedTupleExpr * tupleExpr );
     91                void postvisit( TupleExpr * tupleExpr );
     92                void postvisit( TupleIndexExpr * tupleExpr );
     93                void postvisit( TupleAssignExpr * tupleExpr );
     94                void postvisit( UniqueExpr * unqExpr );
     95                void postvisit( StmtExpr * stmtExpr );
     96                void postvisit( UntypedInitExpr * initExpr );
     97
     98                /// Adds alternatives for anonymous members
     99                void addAnonConversions( const Alternative & alt );
     100                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
     101                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
     102                /// Adds alternatives for member expressions where the left side has tuple type
     103                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
     104                /// Adds alternatives for offsetof expressions, given the base type and name of the member
     105                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
     106                /// Takes a final result and checks if its assertions can be satisfied
     107                template<typename OutputIterator>
     108                void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out );
     109                /// Finds matching alternatives for a function, given a set of arguments
     110                template<typename OutputIterator>
     111                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
     112                /// Checks if assertion parameters match for a new alternative
     113                template< typename OutputIterator >
     114                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
     115        private:
     116                AlternativeFinder & altFinder;
     117                const SymTab::Indexer &indexer;
     118                AltList & alternatives;
     119                const TypeEnvironment &env;
     120                Type *& targetType;
     121        };
     122
    62123        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
    63124                CastExpr *castToVoid = new CastExpr( expr );
    … …  
    152213
    153214                void renameTypes( Expression *expr ) {
    154                         expr->get_result()->accept( global_renamer );
     215                        renameTyVars( expr->result );
    155216                }
    156217        } // namespace
    … …  
    185246
    186247        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) {
    187                 expr->accept( *this );
     248                PassVisitor<Finder> finder( *this );
     249                expr->accept( finder );
    188250                if ( failFast && alternatives.empty() ) {
    189251                        PRINT(
    … …  
    244306        }
    245307
    246         void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
     308        void AlternativeFinder::Finder::addAnonConversions( const Alternative & alt ) {
    247309                // adds anonymous member interpretations whenever an aggregate value type is seen.
    248310                // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
    … …  
    265327
    266328        template< typename StructOrUnionType >
    267         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
     329        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    268330                // by this point, member must be a name expr
    269331                NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
    … …  
    284346        }
    285347
    286         void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
     348        void AlternativeFinder::Finder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    287349                if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
    288350                        // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
    … …  
    308370        }
    309371
    310         void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
     372        void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) {
    311373                alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
    312374        }
    … …  
    485547                        Type *adjType = candidate->get_type()->clone();
    486548                        adjustExprType( adjType, newEnv, indexer );
    487                         adjType->accept( global_renamer );
     549                        renameTyVars( adjType );
    488550                        PRINT(
    489551                                std::cerr << "unifying ";
    … …  
    541603
    542604        template< typename OutputIterator >
    543         void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
     605        void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
    544606//      PRINT(
    545607//          std::cerr << "inferParameters: assertions needed are" << std::endl;
    … …  
    596658                ArgPack()
    597659                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
    598 
    599660                          tupleStart(0), nextExpl(0), explAlt(0) {}
    600661
    … …  
    706767                                                Type* argType;
    707768
    708                                                 if ( nTuples > 0 ) {
    709                                                         // first iteration, push empty tuple expression
     769                                                if ( nTuples > 0 || ! results[i].expr ) {
     770                                                        // first iteration or no expression to clone,
     771                                                        // push empty tuple expression
    710772                                                        newResult.parent = i;
    711773                                                        std::list<Expression*> emptyList;
    … …  
    892954
    893955        template<typename OutputIterator>
    894         void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
     956        void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
    895957                        const std::vector<ArgPack>& results, OutputIterator out ) {
    896958                ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
    … …  
    915977
    916978        template<typename OutputIterator>
    917         void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
     979        void AlternativeFinder::Finder::makeFunctionAlternatives( const Alternative &func,
    918980                        FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) {
    919981                OpenVarSet funcOpenVars;
    … …  
    10221084        }
    10231085
    1024         void AlternativeFinder::visit( UntypedExpr *untypedExpr ) {
     1086        void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) {
    10251087                AlternativeFinder funcFinder( indexer, env );
    10261088                funcFinder.findWithAdjustment( untypedExpr->get_function() );
    … …  
    10291091
    10301092                std::vector< AlternativeFinder > argAlternatives;
    1031                 findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),
     1093                altFinder.findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),
    10321094                        back_inserter( argAlternatives ) );
    10331095
    10341096                // take care of possible tuple assignments
    10351097                // if not tuple assignment, assignment is taken care of as a normal function call
    1036                 Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives );
     1098                Tuples::handleTupleAssignment( altFinder, untypedExpr, argAlternatives );
    10371099
    10381100                // find function operators
    … …  
    11721234                        // fix this issue in a more robust way.
    11731235                        targetType = nullptr;
    1174                         visit( untypedExpr );
     1236                        postvisit( untypedExpr );
    11751237                }
    11761238        }
    … …  
    11811243        }
    11821244
    1183         void AlternativeFinder::visit( AddressExpr *addressExpr ) {
     1245        void AlternativeFinder::Finder::postvisit( AddressExpr *addressExpr ) {
    11841246                AlternativeFinder finder( indexer, env );
    11851247                finder.find( addressExpr->get_arg() );
    … …  
    11921254        }
    11931255
    1194         void AlternativeFinder::visit( LabelAddressExpr * expr ) {
     1256        void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) {
    11951257                alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
    11961258        }
    … …  
    12231285        }
    12241286
    1225         void AlternativeFinder::visit( CastExpr *castExpr ) {
     1287        void AlternativeFinder::Finder::postvisit( CastExpr *castExpr ) {
    12261288                Type *& toType = castExpr->get_result();
    12271289                assert( toType );
    … …  
    12781340        }
    12791341
    1280         void AlternativeFinder::visit( VirtualCastExpr * castExpr ) {
     1342        void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) {
    12811343                assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." );
    12821344                AlternativeFinder finder( indexer, env );
    … …  
    12901352        }
    12911353
    1292         void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
     1354        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
    12931355                AlternativeFinder funcFinder( indexer, env );
    12941356                funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
    … …  
    13121374        }
    13131375
    1314         void AlternativeFinder::visit( MemberExpr *memberExpr ) {
     1376        void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) {
    13151377                alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
    13161378        }
    13171379
    1318         void AlternativeFinder::visit( NameExpr *nameExpr ) {
     1380        void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) {
    13191381                std::list< SymTab::Indexer::IdData > declList;
    13201382                indexer.lookupId( nameExpr->get_name(), declList );
    … …  
    13371399        }
    13381400
    1339         void AlternativeFinder::visit( VariableExpr *variableExpr ) {
     1401        void AlternativeFinder::Finder::postvisit( VariableExpr *variableExpr ) {
    13401402                // not sufficient to clone here, because variable's type may have changed
    13411403                // since the VariableExpr was originally created.
    … …  
    13431405        }
    13441406
    1345         void AlternativeFinder::visit( ConstantExpr *constantExpr ) {
     1407        void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) {
    13461408                alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
    13471409        }
    13481410
    1349         void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
     1411        void AlternativeFinder::Finder::postvisit( SizeofExpr *sizeofExpr ) {
    13501412                if ( sizeofExpr->get_isType() ) {
    13511413                        Type * newType = sizeofExpr->get_type()->clone();
    … …  
    13681430        }
    13691431
    1370         void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
     1432        void AlternativeFinder::Finder::postvisit( AlignofExpr *alignofExpr ) {
    13711433                if ( alignofExpr->get_isType() ) {
    13721434                        Type * newType = alignofExpr->get_type()->clone();
    … …  
    13901452
    13911453        template< typename StructOrUnionType >
    1392         void AlternativeFinder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {
     1454        void AlternativeFinder::Finder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {
    13931455                std::list< Declaration* > members;
    13941456                aggInst->lookup( name, members );
    … …  
    14031465        }
    14041466
    1405         void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) {
     1467        void AlternativeFinder::Finder::postvisit( UntypedOffsetofExpr *offsetofExpr ) {
    14061468                AlternativeFinder funcFinder( indexer, env );
    14071469                // xxx - resolveTypeof?
    … …  
    14131475        }
    14141476
    1415         void AlternativeFinder::visit( OffsetofExpr *offsetofExpr ) {
     1477        void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) {
    14161478                alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) );
    14171479        }
    14181480
    1419         void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) {
     1481        void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) {
    14201482                alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
    14211483        }
    … …  
    14441506        }
    14451507
    1446         void AlternativeFinder::visit( AttrExpr *attrExpr ) {
     1508        void AlternativeFinder::Finder::postvisit( AttrExpr *attrExpr ) {
    14471509                // assume no 'pointer-to-attribute'
    14481510                NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
    … …  
    14581520                                        if ( function->get_parameters().size() == 1 ) {
    14591521                                                if ( attrExpr->get_isType() ) {
    1460                                                         resolveAttr( data, function, attrExpr->get_type(), env, *this );
     1522                                                        resolveAttr( data, function, attrExpr->get_type(), env, altFinder);
    14611523                                                } else {
    14621524                                                        AlternativeFinder finder( indexer, env );
    … …  
    14641526                                                        for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
    14651527                                                                if ( choice->expr->get_result()->size() == 1 ) {
    1466                                                                         resolveAttr(data, function, choice->expr->get_result(), choice->env, *this );
     1528                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder );
    14671529                                                                } // fi
    14681530                                                        } // for
    … …  
    14791541        }
    14801542
    1481         void AlternativeFinder::visit( LogicalExpr *logicalExpr ) {
     1543        void AlternativeFinder::Finder::postvisit( LogicalExpr *logicalExpr ) {
    14821544                AlternativeFinder firstFinder( indexer, env );
    14831545                firstFinder.findWithAdjustment( logicalExpr->get_arg1() );
    … …  
    14921554        }
    14931555
    1494         void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) {
     1556        void AlternativeFinder::Finder::postvisit( ConditionalExpr *conditionalExpr ) {
    14951557                // find alternatives for condition
    14961558                AlternativeFinder firstFinder( indexer, env );
    … …  
    15241586        }
    15251587
    1526         void AlternativeFinder::visit( CommaExpr *commaExpr ) {
     1588        void AlternativeFinder::Finder::postvisit( CommaExpr *commaExpr ) {
    15271589                TypeEnvironment newEnv( env );
    15281590                Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv );
    … …  
    15351597        }
    15361598
    1537         void AlternativeFinder::visit( RangeExpr * rangeExpr ) {
     1599        void AlternativeFinder::Finder::postvisit( RangeExpr * rangeExpr ) {
    15381600                // resolve low and high, accept alternatives whose low and high types unify
    15391601                AlternativeFinder firstFinder( indexer, env );
    … …  
    15571619        }
    15581620
    1559         void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
     1621        void AlternativeFinder::Finder::postvisit( UntypedTupleExpr *tupleExpr ) {
    15601622                std::vector< AlternativeFinder > subExprAlternatives;
    1561                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
     1623                altFinder.findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
    15621624                        back_inserter( subExprAlternatives ) );
    15631625                std::vector< AltList > possibilities;
    … …  
    15751637        }
    15761638
    1577         void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
     1639        void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) {
    15781640                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
    15791641        }
    15801642
    1581         void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
     1643        void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
    15821644                alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
    15831645        }
    15841646
    1585         void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
     1647        void AlternativeFinder::Finder::postvisit( ConstructorExpr * ctorExpr ) {
    15861648                AlternativeFinder finder( indexer, env );
    15871649                // don't prune here, since it's guaranteed all alternatives will have the same type
    … …  
    15931655        }
    15941656
    1595         void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
     1657        void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) {
    15961658                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
    15971659        }
    15981660
    1599         void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
     1661        void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) {
    16001662                alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
    16011663        }
    16021664
    1603         void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
     1665        void AlternativeFinder::Finder::postvisit( UniqueExpr *unqExpr ) {
    16041666                AlternativeFinder finder( indexer, env );
    16051667                finder.findWithAdjustment( unqExpr->get_expr() );
    … …  
    16111673        }
    16121674
    1613         void AlternativeFinder::visit( StmtExpr *stmtExpr ) {
     1675        void AlternativeFinder::Finder::postvisit( StmtExpr *stmtExpr ) {
    16141676                StmtExpr * newStmtExpr = stmtExpr->clone();
    16151677                ResolvExpr::resolveStmtExpr( newStmtExpr, indexer );
    … …  
    16181680        }
    16191681
    1620         void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
     1682        void AlternativeFinder::Finder::postvisit( UntypedInitExpr *initExpr ) {
    16211683                // handle each option like a cast
    16221684                AltList candidates;
    1623                 PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
     1685                PRINT(
     1686                        std::cerr << "untyped init expr: " << initExpr << std::endl;
     1687                )
    16241688                // O(N^2) checks of d-types with e-types
    16251689                for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
    … …  
    16371701                                AssertionSet needAssertions, haveAssertions;
    16381702                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
    1639                                 PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
     1703                                PRINT(
     1704                                        std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
     1705                                 )
    16401706                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
    16411707                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results

  • src/ResolvExpr/AlternativeFinder.h

    rb158d8f rb6838214  
    3838        using ExplodedArgs = std::vector< std::vector< ExplodedActual > >;
    3939
    40         class AlternativeFinder : public Visitor {
     40        class AlternativeFinder {
    4141          public:
    4242                AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
    … …  
    9494                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
    9595          private:
    96                 virtual void visit( ApplicationExpr *applicationExpr );
    97                 virtual void visit( UntypedExpr *untypedExpr );
    98                 virtual void visit( AddressExpr *addressExpr );
    99                 virtual void visit( LabelAddressExpr *labelExpr );
    100                 virtual void visit( CastExpr *castExpr );
    101                 virtual void visit( VirtualCastExpr *castExpr );
    102                 virtual void visit( UntypedMemberExpr *memberExpr );
    103                 virtual void visit( MemberExpr *memberExpr );
    104                 virtual void visit( NameExpr *variableExpr );
    105                 virtual void visit( VariableExpr *variableExpr );
    106                 virtual void visit( ConstantExpr *constantExpr );
    107                 virtual void visit( SizeofExpr *sizeofExpr );
    108                 virtual void visit( AlignofExpr *alignofExpr );
    109                 virtual void visit( UntypedOffsetofExpr *offsetofExpr );
    110                 virtual void visit( OffsetofExpr *offsetofExpr );
    111                 virtual void visit( OffsetPackExpr *offsetPackExpr );
    112                 virtual void visit( AttrExpr *attrExpr );
    113                 virtual void visit( LogicalExpr *logicalExpr );
    114                 virtual void visit( ConditionalExpr *conditionalExpr );
    115                 virtual void visit( CommaExpr *commaExpr );
    116                 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
    117                 virtual void visit( ConstructorExpr * ctorExpr );
    118                 virtual void visit( RangeExpr * rangeExpr );
    119                 virtual void visit( UntypedTupleExpr *tupleExpr );
    120                 virtual void visit( TupleExpr *tupleExpr );
    121                 virtual void visit( TupleIndexExpr *tupleExpr );
    122                 virtual void visit( TupleAssignExpr *tupleExpr );
    123                 virtual void visit( UniqueExpr *unqExpr );
    124                 virtual void visit( StmtExpr *stmtExpr );
    125                 virtual void visit( UntypedInitExpr *initExpr );
    126 
    127                 /// Adds alternatives for anonymous members
    128                 void addAnonConversions( const Alternative & alt );
    129                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    130                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    131                 /// Adds alternatives for member expressions where the left side has tuple type
    132                 void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    133                 /// Adds alternatives for offsetof expressions, given the base type and name of the member
    134                 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
    135                 /// Takes a final result and checks if its assertions can be satisfied
    136                 template<typename OutputIterator>
    137                 void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out );
    138                 /// Finds matching alternatives for a function, given a set of arguments
    139                 template<typename OutputIterator>
    140                 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
    141                 /// Checks if assertion parameters match for a new alternative
    142                 template< typename OutputIterator >
    143                 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
    144 
     96                struct Finder;
    14597                const SymTab::Indexer &indexer;
    14698                AltList alternatives;

  • src/ResolvExpr/CastCost.cc

    rb158d8f rb6838214  
    3131
    3232namespace ResolvExpr {
    33         class CastCost : public ConversionCost {
     33        struct CastCost : public ConversionCost {
    3434          public:
    35                 CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
     35                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
    3636
    37                 virtual void visit( BasicType *basicType );
    38                 virtual void visit( PointerType *pointerType );
     37                using ConversionCost::previsit;
     38                using ConversionCost::postvisit;
     39                void postvisit( BasicType * basicType );
     40                void postvisit( PointerType * pointerType );
    3941        };
    4042
    … …  
    5254                                // all typedefs should be gone by this point
    5355                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
    54                                 if ( type->get_base() ) {
    55                                         return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
     56                                if ( type->base ) {
     57                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
    5658                                } // if
    5759                        } // if
    … …  
    7476                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    7577                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    76                         return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
     78                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
    7779                                return ptrsCastable( t1, t2, env, indexer );
    7880                        });
    7981                } else {
    80                         CastCost converter( dest, indexer, env );
     82                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
    8183                        src->accept( converter );
    82                         if ( converter.get_cost() == Cost::infinity ) {
     84                        if ( converter.pass.get_cost() == Cost::infinity ) {
    8385                                return Cost::infinity;
    8486                        } else {
    8587                                // xxx - why are we adding cost 0 here?
    86                                 return converter.get_cost() + Cost::zero;
     88                                return converter.pass.get_cost() + Cost::zero;
    8789                        } // if
    8890                } // if
    8991        }
    9092
    91         CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
    92                 : ConversionCost( dest, indexer, env ) {
     93        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
     94                : ConversionCost( dest, indexer, env, costFunc ) {
    9395        }
    9496
    95         void CastCost::visit( BasicType *basicType ) {
     97        void CastCost::postvisit( BasicType *basicType ) {
    9698                PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
    9799                if ( destAsPointer && basicType->isInteger() ) {
    … …  
    103105        }
    104106
    105         void CastCost::visit( PointerType *pointerType ) {
     107        void CastCost::postvisit( PointerType *pointerType ) {
    106108                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    107                         if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
     109                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
    108110                                cost = Cost::safe;
    109111                        } else {
    110112                                TypeEnvironment newEnv( env );
    111                                 newEnv.add( pointerType->get_forall() );
    112                                 newEnv.add( pointerType->get_base()->get_forall() );
    113                                 int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
     113                                newEnv.add( pointerType->forall );
     114                                newEnv.add( pointerType->base->forall );
     115                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
    114116                                if ( castResult > 0 ) {
    115117                                        cost = Cost::safe;

  • src/ResolvExpr/CommonType.cc

    rb158d8f rb6838214  
    1818#include <utility>                       // for pair
    1919
     20#include "Common/PassVisitor.h"
    2021#include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
    2122#include "SymTab/Indexer.h"              // for Indexer
    … …  
    2930
    3031namespace ResolvExpr {
    31         class CommonType : public Visitor {
    32           public:
     32        struct CommonType : public WithShortCircuiting {
    3333                CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
    3434                Type *get_result() const { return result; }
     35
     36                void previsit( BaseSyntaxNode * ) { visit_children = false; }
     37
     38                void postvisit( VoidType * voidType );
     39                void postvisit( BasicType * basicType );
     40                void postvisit( PointerType * pointerType );
     41                void postvisit( ArrayType * arrayType );
     42                void postvisit( ReferenceType * refType );
     43                void postvisit( FunctionType * functionType );
     44                void postvisit( StructInstType * aggregateUseType );
     45                void postvisit( UnionInstType * aggregateUseType );
     46                void postvisit( EnumInstType * aggregateUseType );
     47                void postvisit( TraitInstType * aggregateUseType );
     48                void postvisit( TypeInstType * aggregateUseType );
     49                void postvisit( TupleType * tupleType );
     50                void postvisit( VarArgsType * varArgsType );
     51                void postvisit( ZeroType * zeroType );
     52                void postvisit( OneType * oneType );
     53
    3554          private:
    36                 virtual void visit( VoidType *voidType );
    37                 virtual void visit( BasicType *basicType );
    38                 virtual void visit( PointerType *pointerType );
    39                 virtual void visit( ArrayType *arrayType );
    40                 virtual void visit( ReferenceType *refType );
    41                 virtual void visit( FunctionType *functionType );
    42                 virtual void visit( StructInstType *aggregateUseType );
    43                 virtual void visit( UnionInstType *aggregateUseType );
    44                 virtual void visit( EnumInstType *aggregateUseType );
    45                 virtual void visit( TraitInstType *aggregateUseType );
    46                 virtual void visit( TypeInstType *aggregateUseType );
    47                 virtual void visit( TupleType *tupleType );
    48                 virtual void visit( VarArgsType *varArgsType );
    49                 virtual void visit( ZeroType *zeroType );
    50                 virtual void visit( OneType *oneType );
    51 
    5255                template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer );
    5356                template< typename RefType > void handleRefType( RefType *inst, Type *other );
    … …  
    8083
    8184        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
    82                 CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
     85                PassVisitor<CommonType> visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
    8386
    8487                int depth1 = type1->referenceDepth();
    … …  
    9194                        // special case where one type has a reference depth of 1 larger than the other
    9295                        if ( diff > 0 || diff < 0 ) {
     96                                // std::cerr << "reference depth diff: " << diff << std::endl;
    9397                                Type * result = nullptr;
    94                                 if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) {
     98                                ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
     99                                ReferenceType * ref2 = dynamic_cast< ReferenceType * >( type2 );
     100                                if ( diff > 0 ) {
     101                                        // deeper on the left
     102                                        assert( ref1 );
     103                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
     104                                } else {
     105                                        // deeper on the right
     106                                        assert( ref2 );
     107                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
     108                                }
     109                                if ( result && ref1 ) {
    95110                                        // formal is reference, so result should be reference
    96                                         result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
    97                                         if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result );
    98                                 } else {
    99                                         // formal is value, so result should be value
    100                                         ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 );
    101                                         result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
     111                                        // std::cerr << "formal is reference; result should be reference" << std::endl;
     112                                        result = new ReferenceType( ref1->get_qualifiers(), result );
    102113                                }
    103114                                // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
    … …  
    108119
    109120                type1->accept( visitor );
    110                 Type *result = visitor.get_result();
     121                Type *result = visitor.pass.get_result();
    111122                if ( ! result ) {
    112123                        // this appears to be handling for opaque type declarations
    … …  
    180191        }
    181192
    182         void CommonType::visit( __attribute((unused)) VoidType *voidType ) {}
    183 
    184         void CommonType::visit( BasicType *basicType ) {
     193        void CommonType::postvisit( VoidType * ) {}
     194
     195        void CommonType::postvisit( BasicType *basicType ) {
    185196                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
    186197                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
    … …  
    211222        }
    212223
    213         void CommonType::visit( PointerType *pointerType ) {
     224        void CommonType::postvisit( PointerType *pointerType ) {
    214225                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
    215226                        // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
    … …  
    246257        }
    247258
    248         void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
    249 
    250         void CommonType::visit( ReferenceType *refType ) {
     259        void CommonType::postvisit( ArrayType * ) {}
     260
     261        void CommonType::postvisit( ReferenceType *refType ) {
    251262                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
    252263                        // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
    … …  
    283294        }
    284295
    285         void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
    286         void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
    287         void CommonType::visit( __attribute((unused)) UnionInstType *aggregateUseType ) {}
    288 
    289         void CommonType::visit( EnumInstType *enumInstType ) {
     296        void CommonType::postvisit( FunctionType * ) {}
     297        void CommonType::postvisit( StructInstType * ) {}
     298        void CommonType::postvisit( UnionInstType * ) {}
     299
     300        void CommonType::postvisit( EnumInstType *enumInstType ) {
    290301                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
    291302                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
    292                         ValueGuard< Type * > temp( type2 );
    293                         type2 = enumInstType;
    294                         temp.old->accept( *this );
    295                 } // if
    296         }
    297 
    298         void CommonType::visit( __attribute((unused)) TraitInstType *aggregateUseType ) {
    299         }
    300 
    301         void CommonType::visit( TypeInstType *inst ) {
     303                        result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars );
     304                } // if
     305        }
     306
     307        void CommonType::postvisit( TraitInstType * ) {
     308        }
     309
     310        void CommonType::postvisit( TypeInstType *inst ) {
    302311                if ( widenFirst ) {
    303312                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
    … …  
    321330        }
    322331
    323         void CommonType::visit( __attribute((unused)) TupleType *tupleType ) {}
    324         void CommonType::visit( __attribute((unused)) VarArgsType *varArgsType ) {}
    325 
    326         void CommonType::visit( ZeroType *zeroType ) {
     332        void CommonType::postvisit( TupleType * ) {}
     333        void CommonType::postvisit( VarArgsType * ) {}
     334
     335        void CommonType::postvisit( ZeroType *zeroType ) {
    327336                if ( widenFirst ) {
    328337                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
    … …  
    338347        }
    339348
    340         void CommonType::visit( OneType *oneType ) {
     349        void CommonType::postvisit( OneType *oneType ) {
    341350                if ( widenFirst ) {
    342351                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {

  • src/ResolvExpr/ConversionCost.cc

    rb158d8f rb6838214  
    4444                        EqvClass eqvClass;
    4545                        NamedTypeDecl *namedType;
    46                         PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
    47                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     46                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
     47                        if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
    4848                                if ( eqvClass.type ) {
    4949                                        return conversionCost( src, eqvClass.type, indexer, env );
    … …  
    5151                                        return Cost::infinity;
    5252                                }
    53                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
     53                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
    5454                                PRINT( std::cerr << " found" << std::endl; )
    5555                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    5656                                // all typedefs should be gone by this point
    5757                                assert( type );
    58                                 if ( type->get_base() ) {
    59                                         return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
     58                                if ( type->base ) {
     59                                        return conversionCost( src, type->base, indexer, env ) + Cost::safe;
    6060                                } // if
    6161                        } // if
    … …  
    7777                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
    7878                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
    79                         return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){
     79                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
    8080                                return ptrsAssignable( t1, t2, env );
    8181                        });
    8282                } else {
    83                         ConversionCost converter( dest, indexer, env );
     83                        PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
    8484                        src->accept( converter );
    85                         if ( converter.get_cost() == Cost::infinity ) {
     85                        if ( converter.pass.get_cost() == Cost::infinity ) {
    8686                                return Cost::infinity;
    8787                        } else {
    88                                 return converter.get_cost() + Cost::zero;
     88                                return converter.pass.get_cost() + Cost::zero;
    8989                        } // if
    9090                } // if
    … …  
    9292
    9393        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
    94                 PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )
     94                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
    9595                if ( diff > 0 ) {
    9696                        // TODO: document this
    97                         Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
     97                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
    9898                        cost.incReference();
    9999                        return cost;
    100100                } else if ( diff < -1 ) {
    101101                        // TODO: document this
    102                         Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
     102                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
    103103                        cost.incReference();
    104104                        return cost;
    … …  
    108108                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
    109109                                PRINT( std::cerr << "converting between references" << std::endl; )
    110                                 if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
    111                                         return Cost::safe;
     110                                Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
     111                                Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
     112                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
     113                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
     114                                        if ( tq1 == tq2 ) {
     115                                                // types are the same
     116                                                return Cost::zero;
     117                                        } else {
     118                                                // types are the same, except otherPointer has more qualifiers
     119                                                return Cost::safe;
     120                                        }
    112121                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
    113                                         int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
     122                                        int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env );
    114123                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
    115124                                        if ( assignResult > 0 ) {
    … …  
    121130                        } else {
    122131                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
    123                                 ConversionCost converter( dest, indexer, env );
     132                                PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
    124133                                src->accept( converter );
    125                                 return converter.get_cost();
     134                                return converter.pass.get_cost();
    126135                        } // if
    127136                } else {
    … …  
    129138                        assert( diff == -1 && destAsRef );
    130139                        PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
    131                         if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
     140                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
    132141                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
    133142                                if ( src->get_lvalue() ) {
    … …  
    137146                                        )
    138147                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
    139                                         if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
     148                                        if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
    140149                                                return Cost::reference; // cost needs to be non-zero to add cast
    141                                         } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
     150                                        } if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) {
    142151                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
    143152                                        } else {
    144153                                                return Cost::unsafe;
    145154                                        } // if
    146                                 } else if ( destAsRef->get_base()->get_const() ) {
     155                                } else if ( destAsRef->base->get_const() ) {
    147156                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
    148157                                        // rvalue-to-const-reference conversion: T => const T &
    … …  
    164173        }
    165174
    166         ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
    167                 : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) {
     175        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
     176                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
    168177        }
    169178
    … …  
    248257        };
    249258
    250         void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
     259        void ConversionCost::postvisit( VoidType * ) {
    251260                cost = Cost::infinity;
    252261        }
    253262
    254         void ConversionCost::visit(BasicType *basicType) {
     263        void ConversionCost::postvisit(BasicType *basicType) {
    255264                if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
    256265                        int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
    … …  
    269278        }
    270279
    271         void ConversionCost::visit( PointerType * pointerType ) {
     280        void ConversionCost::postvisit( PointerType * pointerType ) {
    272281                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
    273                         PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
    274                         Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
    275                         Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
    276                         if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
     282                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
     283                        Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
     284                        Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
     285                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
     286                                PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    277287                                if ( tq1 == tq2 ) {
    278288                                        // types are the same
    … …  
    280290                                } else {
    281291                                        // types are the same, except otherPointer has more qualifiers
    282                                         PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
    283292                                        cost = Cost::safe;
    284293                                }
    285                         } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
     294                        } else {
    286295                                int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
    287296                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
    288                                 if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
    289                                         cost = Cost::safe;
     297                                if ( assignResult > 0 && tq1 <= tq2 ) {
     298                                        // xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct?
     299                                        if ( tq1 == tq2 ) {
     300                                                cost = Cost::safe;
     301                                        } else if ( tq1 < tq2 ) {
     302                                                cost = Cost::safe+Cost::safe;
     303                                        }
    290304                                } else if ( assignResult < 0 ) {
    291305                                        cost = Cost::unsafe;
    … …  
    298312        }
    299313
    300         void ConversionCost::visit( ArrayType * ) {}
    301 
    302         void ConversionCost::visit( ReferenceType * refType ) {
     314        void ConversionCost::postvisit( ArrayType * ) {}
     315
     316        void ConversionCost::postvisit( ReferenceType * refType ) {
    303317                // Note: dest can never be a reference, since it would have been caught in an earlier check
    304318                assert( ! dynamic_cast< ReferenceType * >( dest ) );
    … …  
    306320                // recursively compute conversion cost from T1 to T2.
    307321                // cv can be safely dropped because of 'implicit dereference' behavior.
    308                 refType->base->accept( *this );
     322                cost = costFunc( refType->base, dest, indexer, env );
    309323                if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
    310324                        cost.incReference();  // prefer exact qualifiers
    … …  
    317331        }
    318332
    319         void ConversionCost::visit( FunctionType * ) {}
    320 
    321         void ConversionCost::visit( StructInstType * inst ) {
     333        void ConversionCost::postvisit( FunctionType * ) {}
     334
     335        void ConversionCost::postvisit( StructInstType * inst ) {
    322336                if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
    323337                        if ( inst->name == destAsInst->name ) {
    … …  
    327341        }
    328342
    329         void ConversionCost::visit( UnionInstType * inst ) {
     343        void ConversionCost::postvisit( UnionInstType * inst ) {
    330344                if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
    331345                        if ( inst->name == destAsInst->name ) {
    … …  
    335349        }
    336350
    337         void ConversionCost::visit( EnumInstType * ) {
     351        void ConversionCost::postvisit( EnumInstType * ) {
    338352                static Type::Qualifiers q;
    339353                static BasicType integer( q, BasicType::SignedInt );
    340                 integer.accept( *this );  // safe if dest >= int
     354                cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
    341355                if ( cost < Cost::unsafe ) {
    342356                        cost.incSafe();
    … …  
    344358        }
    345359
    346         void ConversionCost::visit( TraitInstType * ) {}
    347 
    348         void ConversionCost::visit( TypeInstType *inst ) {
     360        void ConversionCost::postvisit( TraitInstType * ) {}
     361
     362        void ConversionCost::postvisit( TypeInstType *inst ) {
    349363                EqvClass eqvClass;
    350364                NamedTypeDecl *namedType;
    351                 if ( env.lookup( inst->get_name(), eqvClass ) ) {
    352                         cost = conversionCost( eqvClass.type, dest, indexer, env );
     365                if ( env.lookup( inst->name, eqvClass ) ) {
     366                        cost = costFunc( eqvClass.type, dest, indexer, env );
    353367                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    354                         if ( inst->get_name() == destAsInst->get_name() ) {
     368                        if ( inst->name == destAsInst->name ) {
    355369                                cost = Cost::zero;
    356370                        }
    357                 } else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) {
     371                } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
    358372                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    359373                        // all typedefs should be gone by this point
    360374                        assert( type );
    361                         if ( type->get_base() ) {
    362                                 cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
    363                         } // if
    364                 } // if
    365         }
    366 
    367         void ConversionCost::visit( TupleType * tupleType ) {
     375                        if ( type->base ) {
     376                                cost = costFunc( type->base, dest, indexer, env ) + Cost::safe;
     377                        } // if
     378                } // if
     379        }
     380
     381        void ConversionCost::postvisit( TupleType * tupleType ) {
    368382                Cost c = Cost::zero;
    369383                if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
    370                         std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
    371                         std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
    372                         while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
    373                                 Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
     384                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
     385                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
     386                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
     387                                Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env );
    374388                                if ( newCost == Cost::infinity ) {
    375389                                        return;
    … …  
    377391                                c += newCost;
    378392                        } // while
    379                         if ( destIt != destAsTuple->get_types().end() ) {
     393                        if ( destIt != destAsTuple->types.end() ) {
    380394                                cost = Cost::infinity;
    381395                        } else {
    … …  
    385399        }
    386400
    387         void ConversionCost::visit( VarArgsType * ) {
     401        void ConversionCost::postvisit( VarArgsType * ) {
    388402                if ( dynamic_cast< VarArgsType* >( dest ) ) {
    389403                        cost = Cost::zero;
    … …  
    391405        }
    392406
    393         void ConversionCost::visit( ZeroType * ) {
     407        void ConversionCost::postvisit( ZeroType * ) {
    394408                if ( dynamic_cast< ZeroType * >( dest ) ) {
    395409                        cost = Cost::zero;
    … …  
    408422        }
    409423
    410         void ConversionCost::visit( OneType * ) {
     424        void ConversionCost::postvisit( OneType * ) {
    411425                if ( dynamic_cast< OneType * >( dest ) ) {
    412426                        cost = Cost::zero;

  • src/ResolvExpr/ConversionCost.h

    rb158d8f rb6838214  
    1919
    2020#include "Cost.h"             // for Cost
     21
     22#include "Common/PassVisitor.h"
    2123#include "SynTree/Visitor.h"  // for Visitor
    2224#include "SynTree/SynTree.h"  // for Visitor Nodes
    … …  
    2931        class TypeEnvironment;
    3032
    31         class ConversionCost : public Visitor {
     33        typedef std::function<Cost(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
     34        struct ConversionCost : public WithShortCircuiting {
    3235          public:
    33                 ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
     36                ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
    3437
    3538                Cost get_cost() const { return cost; }
    3639
    37                 virtual void visit(VoidType *voidType);
    38                 virtual void visit(BasicType *basicType);
    39                 virtual void visit(PointerType *pointerType);
    40                 virtual void visit(ArrayType *arrayType);
    41                 virtual void visit(ReferenceType *refType);
    42                 virtual void visit(FunctionType *functionType);
    43                 virtual void visit(StructInstType *aggregateUseType);
    44                 virtual void visit(UnionInstType *aggregateUseType);
    45                 virtual void visit(EnumInstType *aggregateUseType);
    46                 virtual void visit(TraitInstType *aggregateUseType);
    47                 virtual void visit(TypeInstType *aggregateUseType);
    48                 virtual void visit(TupleType *tupleType);
    49                 virtual void visit(VarArgsType *varArgsType);
    50                 virtual void visit(ZeroType *zeroType);
    51                 virtual void visit(OneType *oneType);
     40                void previsit( BaseSyntaxNode * ) { visit_children = false; }
     41
     42                void postvisit( VoidType * voidType );
     43                void postvisit( BasicType * basicType );
     44                void postvisit( PointerType * pointerType );
     45                void postvisit( ArrayType * arrayType );
     46                void postvisit( ReferenceType * refType );
     47                void postvisit( FunctionType * functionType );
     48                void postvisit( StructInstType * aggregateUseType );
     49                void postvisit( UnionInstType * aggregateUseType );
     50                void postvisit( EnumInstType * aggregateUseType );
     51                void postvisit( TraitInstType * aggregateUseType );
     52                void postvisit( TypeInstType * aggregateUseType );
     53                void postvisit( TupleType * tupleType );
     54                void postvisit( VarArgsType * varArgsType );
     55                void postvisit( ZeroType * zeroType );
     56                void postvisit( OneType * oneType );
    5257          protected:
    5358                Type *dest;
    … …  
    5560                Cost cost;
    5661                const TypeEnvironment &env;
     62                CostFunction costFunc;
    5763        };
    5864
    59         typedef std::function<int(Type *, Type *, const TypeEnvironment &, const SymTab::Indexer &)> PtrsFunction;
     65        typedef std::function<int(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
    6066        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
    6167} // namespace ResolvExpr

  • src/ResolvExpr/CurrentObject.cc

    rb158d8f rb6838214  
    3838
    3939namespace ResolvExpr {
    40         long long int getConstValue( ConstantExpr * constExpr ) {
    41                 if ( BasicType * basicType = dynamic_cast< BasicType * >( constExpr->get_result() ) ) {
    42                         if ( basicType->isInteger() ) {
    43                                 return constExpr->get_constant()->get_ival();
    44                         } else {
    45                                 assertf( false, "Non-integer constant expression in getConstValue %s", toString( constExpr ).c_str() ); // xxx - might be semantic error
    46                         }
    47                 } else if ( dynamic_cast< OneType * >( constExpr->get_result() ) ) {
    48                         return 1;
    49                 } else if ( dynamic_cast< ZeroType * >( constExpr->get_result() ) ) {
    50                         return 0;
    51                 } else {
    52                         assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
    53                 }
    54         }
    55 
    5640        template< typename AggrInst >
    5741        TypeSubstitution makeGenericSubstitution( AggrInst * inst ) {
    … …  
    7862                virtual ~MemberIterator() {}
    7963
     64                /// walks the current object using the given designators as a guide
    8065                virtual void setPosition( std::list< Expression * > & designators ) = 0;
     66
     67                /// retrieve the list of possible Type/Designaton pairs for the current position in the currect object
    8168                virtual std::list<InitAlternative> operator*() const = 0;
     69
     70                /// true if the iterator is not currently at the end
    8271                virtual operator bool() const = 0;
     72
     73                /// moves the iterator by one member in the current object
    8374                virtual MemberIterator & bigStep() = 0;
     75
     76                /// moves the iterator by one member in the current subobject
    8477                virtual MemberIterator & smallStep() = 0;
     78
     79                /// the type of the current object
    8580                virtual Type * getType() = 0;
     81
     82                /// the type of the current subobject
    8683                virtual Type * getNext() = 0;
    8784
     85                /// printing for debug
    8886                virtual void print( std::ostream & out, Indenter indent ) const = 0;
    8987
     88                /// helper for operator*; aggregates must add designator to each init alternative, but
     89                /// adding designators in operator* creates duplicates.
    9090                virtual std::list<InitAlternative> first() const = 0; // should be protected
    9191        };
    … …  
    141141                        base = at->get_base();
    142142                        memberIter = createMemberIterator( base );
     143                        if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
    143144                        setSize( at->get_dimension() );
    144145                }
    … …  
    151152                void setSize( Expression * expr ) {
    152153                        if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
    153                                 size = getConstValue( constExpr );
    154                                 PRINT( std::cerr << "array type with size: " << size << std::endl; )
     154                                try {
     155                                        size = constExpr->intValue();
     156                                        PRINT( std::cerr << "array type with size: " << size << std::endl; )
     157                                } catch ( SemanticError & ) {
     158                                        throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr );
     159                                }
    155160                        }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
    156161                                setSize( castExpr->get_arg() ); // xxx - need to perform the conversion specified by the cast
     162                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
     163                                if ( EnumInstType * inst = dynamic_cast< EnumInstType * > ( varExpr->result ) ) {
     164                                        long long int value;
     165                                        if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
     166                                                size = value;
     167                                        }
     168                                }
    157169                        } else {
    158170                                assertf( false, "unhandled expression in setSize: %s", toString( expr ).c_str() ); // xxx - if not a constant expression, it's not simple to determine how long the array actually is, which is necessary for initialization to be done correctly -- fix this
    … …  
    164176                        // need to permit integer-constant-expressions, including: integer constants, enumeration constants, character constants, sizeof expressions, _Alignof expressions, cast expressions
    165177                        if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
    166                                 index = getConstValue( constExpr );
     178                                try {
     179                                        index = constExpr->intValue();
     180                                } catch( SemanticError & ) {
     181                                        throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
     182                                }
    167183                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
    168184                                setPosition( castExpr->get_arg() );
    169185                        } else if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
    170                                 assertf( dynamic_cast<EnumInstType *> ( varExpr->get_result() ), "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
    171                                 index = 0; // xxx - get actual value of enum constant
     186                                EnumInstType * inst = dynamic_cast<EnumInstType *>( varExpr->get_result() );
     187                                assertf( inst, "ArrayIterator given variable that isn't an enum constant : %s", toString( expr ).c_str() );
     188                                long long int value;
     189                                if ( inst->baseEnum->valueOf( varExpr->var, value ) ) {
     190                                        index = value;
     191                                }
    172192                        } else if ( dynamic_cast< SizeofExpr * >( expr ) || dynamic_cast< AlignofExpr * >( expr ) ) {
    173193                                index = 0; // xxx - get actual sizeof/alignof value?
    … …  
    350370                                }
    351371                        }
    352                         // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction
    353                         if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction
     372                        if ( atbegin ) {
    354373                                // xxx - what about case of empty struct??
    355374                                // only add self if at the very beginning of the structure
    … …  
    385404                        return *this;
    386405                }
    387                 virtual std::list<InitAlternative> first() const { return std::list<InitAlternative>{}; }
    388406        };
    389407
    … …  
    439457                                return new UnionIterator( uit );
    440458                        } else {
    441                                 assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
     459                                assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() );
    442460                                return new SimpleIterator( type );
    443461                        }

  • src/ResolvExpr/FindOpenVars.cc

    rb158d8f rb6838214  
    1919#include <map>                    // for map<>::mapped_type
    2020
     21#include "Common/PassVisitor.h"
    2122#include "SynTree/Declaration.h"  // for TypeDecl, DeclarationWithType (ptr ...
    2223#include "SynTree/Type.h"         // for Type, Type::ForallList, ArrayType
    23 #include "SynTree/Visitor.h"      // for Visitor
    2424
    2525namespace ResolvExpr {
    26         class FindOpenVars : public Visitor {
    27           public:
     26        struct FindOpenVars : public WithGuards {
    2827                FindOpenVars( OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen );
    2928
    30           private:
    31                 virtual void visit(PointerType *pointerType);
    32                 virtual void visit(ArrayType *arrayType);
    33                 virtual void visit(FunctionType *functionType);
    34                 virtual void visit(TupleType *tupleType);
     29                void previsit( PointerType * pointerType );
     30                void previsit( ArrayType * arrayType );
     31                void previsit( FunctionType * functionType );
     32                void previsit( TupleType * tupleType );
    3533
    3634                void common_action( Type *type );
    … …  
    4240
    4341        void findOpenVars( Type *type, OpenVarSet &openVars, OpenVarSet &closedVars, AssertionSet &needAssertions, AssertionSet &haveAssertions, bool firstIsOpen ) {
    44                 FindOpenVars finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
     42                PassVisitor<FindOpenVars> finder( openVars, closedVars, needAssertions, haveAssertions, firstIsOpen );
    4543                type->accept( finder );
    4644        }
    … …  
    7068                        } // for
    7169                } // if
    72 ///   std::cout << "type is ";
    73 ///   type->print( std::cout );
    74 ///   std::cout << std::endl << "need is" << std::endl;
    75 ///   printAssertionSet( needAssertions, std::cout );
    76 ///   std::cout << std::endl << "have is" << std::endl;
    77 ///   printAssertionSet( haveAssertions, std::cout );
     70///   std::cerr << "type is ";
     71///   type->print( std::cerr );
     72///   std::cerr << std::endl << "need is" << std::endl;
     73///   printAssertionSet( needAssertions, std::cerr );
     74///   std::cerr << std::endl << "have is" << std::endl;
     75///   printAssertionSet( haveAssertions, std::cerr );
    7876        }
    7977
    80         void FindOpenVars::visit(PointerType *pointerType) {
     78        void FindOpenVars::previsit(PointerType *pointerType) {
    8179                common_action( pointerType );
    82                 Visitor::visit( pointerType );
    8380        }
    8481
    85         void FindOpenVars::visit(ArrayType *arrayType) {
     82        void FindOpenVars::previsit(ArrayType *arrayType) {
    8683                common_action( arrayType );
    87                 Visitor::visit( arrayType );
    8884        }
    8985
    90         void FindOpenVars::visit(FunctionType *functionType) {
     86        void FindOpenVars::previsit(FunctionType *functionType) {
    9187                common_action( functionType );
    9288                nextIsOpen = ! nextIsOpen;
    93                 Visitor::visit( functionType );
    94                 nextIsOpen = ! nextIsOpen;
     89                GuardAction( [this](){ nextIsOpen = ! nextIsOpen; } );
    9590        }
    9691
    97         void FindOpenVars::visit(TupleType *tupleType) {
     92        void FindOpenVars::previsit(TupleType *tupleType) {
    9893                common_action( tupleType );
    99                 Visitor::visit( tupleType );
    10094        }
    10195} // namespace ResolvExpr

  • src/ResolvExpr/Occurs.cc

    rb158d8f rb6838214  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Occurs.cc -- 
     7// Occurs.cc --
    88//
    99// Author           : Richard C. Bilson
    … …  
    1717#include <string>             // for string
    1818
     19#include "Common/PassVisitor.h"
    1920#include "SynTree/Type.h"     // for TypeInstType, Type
    20 #include "SynTree/Visitor.h"  // for Visitor
    2121#include "TypeEnvironment.h"  // for EqvClass, TypeEnvironment
    2222
    2323namespace ResolvExpr {
    24         class Occurs : public Visitor {
    25           public:
     24        struct Occurs : public WithVisitorRef<Occurs> {
    2625                Occurs( std::string varName, const TypeEnvironment &env );
    27                 bool get_result() const { return result; }
    28                 virtual void visit( TypeInstType *typeInst );
    29           private:
     26                void previsit( TypeInstType * typeInst );
     27
    3028                bool result;
    3129                std::set< std::string > eqvVars;
    32                 const TypeEnvironment &env;
     30                const TypeEnvironment &tenv;
    3331        };
    3432
    3533        bool occurs( Type *type, std::string varName, const TypeEnvironment &env ) {
    36                 Occurs occur( varName, env );
     34                PassVisitor<Occurs> occur( varName, env );
    3735                type->accept( occur );
    38                 return occur.get_result();
     36                return occur.pass.result;
    3937        }
    4038
    41         Occurs::Occurs( std::string varName, const TypeEnvironment &env ) : result( false ), env( env ) {
     39        Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) {
    4240                EqvClass eqvClass;
    43                 if ( env.lookup( varName, eqvClass ) ) {
     41                if ( tenv.lookup( varName, eqvClass ) ) {
    4442                        eqvVars = eqvClass.vars;
    4543                } else {
    … …  
    4846        }
    4947
    50         void Occurs::visit( TypeInstType *typeInst ) {
     48        void Occurs::previsit( TypeInstType * typeInst ) {
    5149                EqvClass eqvClass;
    52 ///   std::cout << "searching for vars: ";
    53 ///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cout, " " ) );
    54 ///   std::cout << std::endl;
     50///   std::cerr << "searching for vars: ";
     51///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );
     52///   std::cerr << std::endl;
    5553                if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) {
    5654                        result = true;
    57                 } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
     55                } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
    5856                        if ( eqvClass.type ) {
    59 ///       std::cout << typeInst->get_name() << " is bound to";
    60 ///       eqvClass.type->print( std::cout );
    61 ///       std::cout << std::endl;
    62                                 eqvClass.type->accept( *this );
     57///       std::cerr << typeInst->get_name() << " is bound to";
     58///       eqvClass.type->print( std::cerr );
     59///       std::cerr << std::endl;
     60                                eqvClass.type->accept( *visitor );
    6361                        } // if
    6462                } // if

  • src/ResolvExpr/PolyCost.cc

    rb158d8f rb6838214  
    1414//
    1515
     16#include "Common/PassVisitor.h"
    1617#include "SymTab/Indexer.h"   // for Indexer
    1718#include "SynTree/Type.h"     // for TypeInstType, Type
    18 #include "SynTree/Visitor.h"  // for Visitor
    1919#include "TypeEnvironment.h"  // for EqvClass, TypeEnvironment
    2020
    2121namespace ResolvExpr {
    22         class PolyCost : public Visitor {
    23           public:
     22        struct PolyCost {
    2423                PolyCost( const TypeEnvironment &env, const SymTab::Indexer &indexer );
    25                 int get_result() const { return result; }
    26           private:
    27                 virtual void visit(TypeInstType *aggregateUseType);
     24
     25                void previsit( TypeInstType * aggregateUseType );
    2826                int result;
    29                 const TypeEnvironment &env;
     27                const TypeEnvironment &tenv;
    3028                const SymTab::Indexer &indexer;
    3129        };
    3230
    3331        int polyCost( Type *type, const TypeEnvironment & env, const SymTab::Indexer &indexer ) {
    34                 PolyCost coster( env, indexer );
     32                PassVisitor<PolyCost> coster( env, indexer );
    3533                type->accept( coster );
    36                 return coster.get_result();
     34                return coster.pass.result;
    3735        }
    3836
    39         PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), env( env ), indexer( indexer ) {
     37        PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), tenv( env ), indexer( indexer ) {
    4038        }
    4139
    42         void PolyCost::visit(TypeInstType * typeInst) {
     40        void PolyCost::previsit(TypeInstType * typeInst) {
    4341                EqvClass eqvClass;
    44                 if ( env.lookup( typeInst->name, eqvClass ) ) {
     42                if ( tenv.lookup( typeInst->name, eqvClass ) ) {
    4543                        if ( eqvClass.type ) {
    4644                                if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {

  • src/ResolvExpr/PtrsAssignable.cc

    rb158d8f rb6838214  
    1414//
    1515
     16#include "Common/PassVisitor.h"
    1617#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
    1718#include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
    … …  
    2021
    2122namespace ResolvExpr {
    22         class PtrsAssignable : public Visitor {
    23           public:
     23        struct PtrsAssignable : public WithShortCircuiting {
    2424                PtrsAssignable( Type *dest, const TypeEnvironment &env );
    2525
    2626                int get_result() const { return result; }
    2727
    28                 virtual void visit( VoidType *voidType );
    29                 virtual void visit( BasicType *basicType );
    30                 virtual void visit( PointerType *pointerType );
    31                 virtual void visit( ArrayType *arrayType );
    32                 virtual void visit( FunctionType *functionType );
    33                 virtual void visit( StructInstType *inst );
    34                 virtual void visit( UnionInstType *inst );
    35                 virtual void visit( EnumInstType *inst );
    36                 virtual void visit( TraitInstType *inst );
    37                 virtual void visit( TypeInstType *inst );
    38                 virtual void visit( TupleType *tupleType );
    39                 virtual void visit( VarArgsType *varArgsType );
    40                 virtual void visit( ZeroType *zeroType );
    41                 virtual void visit( OneType *oneType );
     28                void previsit( Type * ) { visit_children = false; }
     29
     30                void postvisit( VoidType * voidType );
     31                void postvisit( BasicType * basicType );
     32                void postvisit( PointerType * pointerType );
     33                void postvisit( ArrayType * arrayType );
     34                void postvisit( FunctionType * functionType );
     35                void postvisit( StructInstType * inst );
     36                void postvisit( UnionInstType * inst );
     37                void postvisit( EnumInstType * inst );
     38                void postvisit( TraitInstType * inst );
     39                void postvisit( TypeInstType * inst );
     40                void postvisit( TupleType * tupleType );
     41                void postvisit( VarArgsType * varArgsType );
     42                void postvisit( ZeroType * zeroType );
     43                void postvisit( OneType * oneType );
    4244          private:
    4345                Type *dest;
    … …  
    5961                        return -1;
    6062                } else {
    61                         PtrsAssignable ptrs( dest, env );
     63                        PassVisitor<PtrsAssignable> ptrs( dest, env );
    6264                        src->accept( ptrs );
    63                         return ptrs.get_result();
     65                        return ptrs.pass.get_result();
    6466                } // if
    6567        }
    … …  
    6769        PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
    6870
    69         void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
     71        void PtrsAssignable::postvisit( VoidType * ) {
    7072                // T * = void * is disallowed - this is a change from C, where any
    7173                // void * can be assigned or passed to a non-void pointer without a cast.
    7274        }
    7375
    74         void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
    75         void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
    76         void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
    77         void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {}
     76        void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {}
     77        void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {}
     78        void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {}
     79        void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {}
    7880
    79         void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
    80         void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
     81        void PtrsAssignable::postvisit(  __attribute__((unused)) StructInstType *inst ) {}
     82        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
    8183
    82         void PtrsAssignable::visit( EnumInstType * ) {
     84        void PtrsAssignable::postvisit( EnumInstType * ) {
    8385                if ( dynamic_cast< BasicType* >( dest ) ) {
    8486                        // int * = E *, etc. is safe. This isn't technically correct, as each
    … …  
    9193        }
    9294
    93         void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
    94         void PtrsAssignable::visit( TypeInstType *inst ) {
     95        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
     96        void PtrsAssignable::postvisit( TypeInstType *inst ) {
    9597                EqvClass eqvClass;
    9698                if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
    … …  
    100102        }
    101103
    102         void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
    103         void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
    104         void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
    105         void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
     104        void PtrsAssignable::postvisit(  __attribute__((unused)) TupleType *tupleType ) {}
     105        void PtrsAssignable::postvisit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
     106        void PtrsAssignable::postvisit(  __attribute__((unused)) ZeroType *zeroType ) {}
     107        void PtrsAssignable::postvisit(  __attribute__((unused)) OneType *oneType ) {}
    106108
    107109} // namespace ResolvExpr

  • src/ResolvExpr/PtrsCastable.cc

    rb158d8f rb6838214  
    1414//
    1515
     16#include "Common/PassVisitor.h"
    1617#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
    1718#include "SymTab/Indexer.h"              // for Indexer
    … …  
    2122#include "typeops.h"                     // for ptrsAssignable
    2223
    23 
    2424namespace ResolvExpr {
    25         class PtrsCastable : public Visitor {
     25        struct PtrsCastable : public WithShortCircuiting {
    2626          public:
    2727                PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
    … …  
    2929                int get_result() const { return result; }
    3030
    31                 virtual void visit(VoidType *voidType);
    32                 virtual void visit(BasicType *basicType);
    33                 virtual void visit(PointerType *pointerType);
    34                 virtual void visit(ArrayType *arrayType);
    35                 virtual void visit(FunctionType *functionType);
    36                 virtual void visit(StructInstType *inst);
    37                 virtual void visit(UnionInstType *inst);
    38                 virtual void visit(EnumInstType *inst);
    39                 virtual void visit(TraitInstType *inst);
    40                 virtual void visit(TypeInstType *inst);
    41                 virtual void visit(TupleType *tupleType);
    42                 virtual void visit(VarArgsType *varArgsType);
    43                 virtual void visit(ZeroType *zeroType);
    44                 virtual void visit(OneType *oneType);
     31                void previsit( Type * ) { visit_children = false; }
     32
     33                void postvisit( VoidType * voidType );
     34                void postvisit( BasicType * basicType );
     35                void postvisit( PointerType * pointerType );
     36                void postvisit( ArrayType * arrayType );
     37                void postvisit( FunctionType * functionType );
     38                void postvisit( StructInstType * inst );
     39                void postvisit( UnionInstType * inst );
     40                void postvisit( EnumInstType * inst );
     41                void postvisit( TraitInstType * inst );
     42                void postvisit( TypeInstType * inst );
     43                void postvisit( TupleType * tupleType );
     44                void postvisit( VarArgsType * varArgsType );
     45                void postvisit( ZeroType * zeroType );
     46                void postvisit( OneType * oneType );
    4547          private:
    4648                Type *dest;
    … …  
    7981                        EqvClass eqvClass;
    8082                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     83                                // xxx - should this be ptrsCastable?
    8184                                return ptrsAssignable( src, eqvClass.type, env );
    8285                        } // if
    … …  
    8588                        return objectCast( src, env, indexer );
    8689                } else {
    87                         PtrsCastable ptrs( dest, env, indexer );
     90                        PassVisitor<PtrsCastable> ptrs( dest, env, indexer );
    8891                        src->accept( ptrs );
    89                         return ptrs.get_result();
     92                        return ptrs.pass.get_result();
    9093                } // if
    9194        }
    … …  
    9598        }
    9699
    97         void PtrsCastable::visit( VoidType * ) {
     100        void PtrsCastable::postvisit( VoidType * ) {
    98101                result = objectCast( dest, env, indexer );
    99102        }
    100103
    101         void PtrsCastable::visit( BasicType * ) {
     104        void PtrsCastable::postvisit( BasicType * ) {
    102105                result = objectCast( dest, env, indexer );
    103106        }
    104107
    105         void PtrsCastable::visit( PointerType * ) {
     108        void PtrsCastable::postvisit( PointerType * ) {
    106109                result = objectCast( dest, env, indexer );
    107110        }
    108111
    109         void PtrsCastable::visit( ArrayType * ) {
     112        void PtrsCastable::postvisit( ArrayType * ) {
    110113                result = objectCast( dest, env, indexer );
    111114        }
    112115
    113         void PtrsCastable::visit( FunctionType * ) {
     116        void PtrsCastable::postvisit( FunctionType * ) {
    114117                // result = -1;
    115118                result = functionCast( dest, env, indexer );
    116119        }
    117120
    118         void PtrsCastable::visit( StructInstType * ) {
     121        void PtrsCastable::postvisit( StructInstType * ) {
    119122                result = objectCast( dest, env, indexer );
    120123        }
    121124
    122         void PtrsCastable::visit( UnionInstType * ) {
     125        void PtrsCastable::postvisit( UnionInstType * ) {
    123126                result = objectCast( dest, env, indexer );
    124127        }
    125128
    126         void PtrsCastable::visit( EnumInstType * ) {
     129        void PtrsCastable::postvisit( EnumInstType * ) {
    127130                if ( dynamic_cast< EnumInstType* >( dest ) ) {
    128131                        result = 1;
    … …  
    138141        }
    139142
    140         void PtrsCastable::visit( TraitInstType * ) {}
     143        void PtrsCastable::postvisit( TraitInstType * ) {}
    141144
    142         void PtrsCastable::visit(TypeInstType *inst) {
     145        void PtrsCastable::postvisit(TypeInstType *inst) {
    143146                //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
    144147                result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
    145148        }
    146149
    147         void PtrsCastable::visit( TupleType * ) {
     150        void PtrsCastable::postvisit( TupleType * ) {
    148151                result = objectCast( dest, env, indexer );
    149152        }
    150153
    151         void PtrsCastable::visit( VarArgsType * ) {
     154        void PtrsCastable::postvisit( VarArgsType * ) {
    152155                result = objectCast( dest, env, indexer );
    153156        }
    154157
    155         void PtrsCastable::visit( ZeroType * ) {
     158        void PtrsCastable::postvisit( ZeroType * ) {
    156159                result = objectCast( dest, env, indexer );
    157160        }
    158161
    159         void PtrsCastable::visit( OneType * ) {
     162        void PtrsCastable::postvisit( OneType * ) {
    160163                result = objectCast( dest, env, indexer );
    161164        }

  • src/ResolvExpr/RenameVars.cc

    rb158d8f rb6838214  
    1919#include <utility>                 // for pair
    2020
     21#include "Common/PassVisitor.h"
    2122#include "Common/SemanticError.h"  // for SemanticError
    2223#include "RenameVars.h"
    … …  
    2728
    2829namespace ResolvExpr {
    29         RenameVars global_renamer;
     30        namespace {
     31                struct RenameVars {
     32                        RenameVars();
     33                        void reset();
    3034
    31         RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
    32                 mapStack.push_front( std::map< std::string, std::string >() );
     35                        void previsit( TypeInstType * instType );
     36                        void previsit( Type * );
     37                        void postvisit( Type * );
     38
     39                  private:
     40                        int level, resetCount;
     41                        std::list< std::map< std::string, std::string > > mapStack;
     42                };
     43
     44                PassVisitor<RenameVars> global_renamer;
     45        } // namespace
     46
     47        void renameTyVars( Type * t ) {
     48                t->accept( global_renamer );
    3349        }
    3450
    35         void RenameVars::reset() {
    36                 level = 0;
    37                 resetCount++;
     51        void resetTyVarRenaming() {
     52                global_renamer.pass.reset();
    3853        }
    3954
    40         void RenameVars::visit( VoidType *voidType ) {
    41                 typeBefore( voidType );
    42                 typeAfter( voidType );
    43         }
     55        namespace {
     56                RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
     57                        mapStack.push_front( std::map< std::string, std::string >() );
     58                }
    4459
    45         void RenameVars::visit( BasicType *basicType ) {
    46                 typeBefore( basicType );
    47                 typeAfter( basicType );
    48         }
     60                void RenameVars::reset() {
     61                        level = 0;
     62                        resetCount++;
     63                }
    4964
    50         void RenameVars::visit( PointerType *pointerType ) {
    51                 typeBefore( pointerType );
    52                 maybeAccept( pointerType->get_base(), *this );
    53                 typeAfter( pointerType );
    54         }
     65                void RenameVars::previsit( TypeInstType * instType ) {
     66                        previsit( (Type *)instType );
     67                        std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
     68                        if ( i != mapStack.front().end() ) {
     69                                instType->name = i->second;
     70                        } // if
     71                }
    5572
    56         void RenameVars::visit( ArrayType *arrayType ) {
    57                 typeBefore( arrayType );
    58                 maybeAccept( arrayType->get_dimension(), *this );
    59                 maybeAccept( arrayType->get_base(), *this );
    60                 typeAfter( arrayType );
    61         }
     73                void RenameVars::previsit( Type * type ) {
     74                        if ( ! type->forall.empty() ) {
     75                                // copies current name mapping into new mapping
     76                                mapStack.push_front( mapStack.front() );
     77                                // renames all "forall" type names to `_${level}_${name}'
     78                                for ( auto td : type->forall ) {
     79                                        std::ostringstream output;
     80                                        output << "_" << resetCount << "_" << level << "_" << td->name;
     81                                        std::string newname( output.str() );
     82                                        mapStack.front()[ td->get_name() ] = newname;
     83                                        td->name = newname;
     84                                        // ditto for assertion names, the next level in
     85                                        level++;
     86                                        // acceptAll( td->assertions, *this );
     87                                } // for
     88                        } // if
     89                }
    6290
    63         void RenameVars::visit( FunctionType *functionType ) {
    64                 typeBefore( functionType );
    65                 acceptAll( functionType->get_returnVals(), *this );
    66                 acceptAll( functionType->get_parameters(), *this );
    67                 typeAfter( functionType );
    68         }
    69 
    70         void RenameVars::visit( StructInstType *aggregateUseType ) {
    71                 typeBefore( aggregateUseType );
    72                 acceptAll( aggregateUseType->get_parameters(), *this );
    73                 typeAfter( aggregateUseType );
    74         }
    75 
    76         void RenameVars::visit( UnionInstType *aggregateUseType ) {
    77                 typeBefore( aggregateUseType );
    78                 acceptAll( aggregateUseType->get_parameters(), *this );
    79                 typeAfter( aggregateUseType );
    80         }
    81 
    82         void RenameVars::visit( EnumInstType *aggregateUseType ) {
    83                 typeBefore( aggregateUseType );
    84                 acceptAll( aggregateUseType->get_parameters(), *this );
    85                 typeAfter( aggregateUseType );
    86         }
    87 
    88         void RenameVars::visit( TraitInstType *aggregateUseType ) {
    89                 typeBefore( aggregateUseType );
    90                 acceptAll( aggregateUseType->get_parameters(), *this );
    91                 typeAfter( aggregateUseType );
    92         }
    93 
    94         void RenameVars::visit( TypeInstType *instType ) {
    95                 typeBefore( instType );
    96                 std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->get_name() );
    97                 if ( i != mapStack.front().end() ) {
    98                         instType->set_name( i->second );
    99                 } else {
    100                 } // if
    101                 acceptAll( instType->get_parameters(), *this );
    102                 typeAfter( instType );
    103         }
    104 
    105         void RenameVars::visit( TupleType *tupleType ) {
    106                 typeBefore( tupleType );
    107                 acceptAll( tupleType->get_types(), *this );
    108                 typeAfter( tupleType );
    109         }
    110 
    111         void RenameVars::visit( VarArgsType *varArgsType ) {
    112                 typeBefore( varArgsType );
    113                 typeAfter( varArgsType );
    114         }
    115 
    116         void RenameVars::visit( ZeroType *zeroType ) {
    117                 typeBefore( zeroType );
    118                 typeAfter( zeroType );
    119         }
    120 
    121         void RenameVars::visit( OneType *oneType ) {
    122                 typeBefore( oneType );
    123                 typeAfter( oneType );
    124         }
    125 
    126         void RenameVars::typeBefore( Type *type ) {
    127                 if ( ! type->get_forall().empty() ) {
    128                         // copies current name mapping into new mapping
    129                         mapStack.push_front( mapStack.front() );
    130                         // renames all "forall" type names to `_${level}_${name}'
    131                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    132                                 std::ostringstream output;
    133                                 output << "_" << resetCount << "_" << level << "_" << (*i)->get_name();
    134                                 std::string newname( output.str() );
    135                                 mapStack.front()[ (*i)->get_name() ] = newname;
    136                                 (*i)->set_name( newname );
    137                                 // ditto for assertion names, the next level in
    138                                 level++;
    139                                 acceptAll( (*i)->get_assertions(), *this );
    140                         } // for
    141                 } // if
    142         }
    143 
    144         void RenameVars::typeAfter( Type *type ) {
    145                 // clears name mapping added by typeBefore()
    146                 if ( ! type->get_forall().empty() ) {
    147                         mapStack.pop_front();
    148                 } // if
    149         }
    150 
     91                void RenameVars::postvisit( Type * type ) {
     92                        // clears name mapping added by typeBefore()
     93                        if ( ! type->forall.empty() ) {
     94                                mapStack.pop_front();
     95                        } // if
     96                }
     97        } // namespace
    15198} // namespace ResolvExpr
    15299

  • src/ResolvExpr/RenameVars.h

    rb158d8f rb6838214  
    2424
    2525namespace ResolvExpr {
     26        /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
     27        void renameTyVars( Type * );
    2628
    27         /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
    28         class RenameVars : public Visitor {
    29           public:
    30                 RenameVars();
    31                 void reset();
    32           private:
    33                 virtual void visit( VoidType *basicType );
    34                 virtual void visit( BasicType *basicType );
    35                 virtual void visit( PointerType *pointerType );
    36                 virtual void visit( ArrayType *arrayType );
    37                 virtual void visit( FunctionType *functionType );
    38                 virtual void visit( StructInstType *aggregateUseType );
    39                 virtual void visit( UnionInstType *aggregateUseType );
    40                 virtual void visit( EnumInstType *aggregateUseType );
    41                 virtual void visit( TraitInstType *aggregateUseType );
    42                 virtual void visit( TypeInstType *aggregateUseType );
    43                 virtual void visit( TupleType *tupleType );
    44                 virtual void visit( VarArgsType *varArgsType );
    45                 virtual void visit( ZeroType *zeroType );
    46                 virtual void visit( OneType *oneType );
    47 
    48                 void typeBefore( Type *type );
    49                 void typeAfter( Type *type );
    50                 int level, resetCount;
    51                 std::list< std::map< std::string, std::string > > mapStack;
    52         };
    53 
    54         extern RenameVars global_renamer;
     29        /// resets internal state of renamer to avoid overflow
     30        void resetTyVarRenaming();
    5531} // namespace ResolvExpr
    5632

  • src/ResolvExpr/Resolver.cc

    rb158d8f rb6838214  
    132132
    133133        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
    134                 global_renamer.reset();
     134                resetTyVarRenaming();
    135135                TypeEnvironment env;
    136136                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
    … …  
    155155                } // if
    156156                #endif
    157                 assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
     157                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end: (%zd) %s", finder.get_alternatives().size(), toString( untyped ).c_str() );
    158158                Alternative &choice = finder.get_alternatives().front();
    159159                Expression *newExpr = choice.expr->clone();
    … …  
    171171
    172172        namespace {
     173                /// resolve `untyped` to the expression whose type satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
     174                template<typename Pred>
     175                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, Pred pred) {
     176                        TypeEnvironment env;
     177                        AlternativeFinder finder( indexer, env );
     178                        finder.findWithAdjustment( untyped );
     179
     180                        AltList candidates;
     181                        for ( Alternative & alt : finder.get_alternatives() ) {
     182                                if ( pred( alt.expr->result ) ) {
     183                                        candidates.push_back( std::move( alt ) );
     184                                }
     185                        }
     186
     187                        // choose the lowest cost expression among the candidates
     188                        AltList winners;
     189                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
     190                        if ( winners.size() == 0 ) {
     191                                throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped );
     192                        } else if ( winners.size() != 1 ) {
     193                                std::ostringstream stream;
     194                                stream << "Cannot choose between " << winners.size() << " alternatives for " + kindStr +  " expression\n";
     195                                untyped->print( stream );
     196                                stream << "Alternatives are:\n";
     197                                printAlts( winners, stream, 1 );
     198                                throw SemanticError( stream.str() );
     199                        }
     200
     201                        // there is one unambiguous interpretation - move the expression into the with statement
     202                        Alternative & alt = winners.front();
     203                        finishExpr( alt.expr, alt.env, untyped->env );
     204                        delete untyped;
     205                        untyped = alt.expr;
     206                        alt.expr = nullptr;
     207                }
     208
    173209                bool isIntegralType( Type *type ) {
    174210                        if ( dynamic_cast< EnumInstType * >( type ) ) {
    … …  
    184220
    185221                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
    186                         TypeEnvironment env;
    187                         AlternativeFinder finder( indexer, env );
    188                         finder.find( untyped );
    189 #if 0
    190                         if ( finder.get_alternatives().size() != 1 ) {
    191                                 std::cout << "untyped expr is ";
    192                                 untyped->print( std::cout );
    193                                 std::cout << std::endl << "alternatives are:";
    194                                 for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    195                                         i->print( std::cout );
    196                                 } // for
    197                         } // if
    198 #endif
    199                         Expression *newExpr = 0;
    200                         const TypeEnvironment *newEnv = 0;
    201                         for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    202                                 if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
    203                                         if ( newExpr ) {
    204                                                 throw SemanticError( "Too many interpretations for case control expression", untyped );
    205                                         } else {
    206                                                 newExpr = i->expr->clone();
    207                                                 newEnv = &i->env;
    208                                         } // if
    209                                 } // if
    210                         } // for
    211                         if ( ! newExpr ) {
    212                                 throw SemanticError( "No interpretations for case control expression", untyped );
    213                         } // if
    214                         finishExpr( newExpr, *newEnv, untyped->env );
    215                         delete untyped;
    216                         untyped = newExpr;
    217                 }
    218 
     222                        findKindExpression( untyped, indexer, "condition", isIntegralType );
     223                }
    219224        }
    220225
    … …  
    311316
    312317        void Resolver::previsit( IfStmt *ifStmt ) {
    313                 findSingleExpression( ifStmt->condition, indexer );
     318                findIntegralExpression( ifStmt->condition, indexer );
    314319        }
    315320
    316321        void Resolver::previsit( WhileStmt *whileStmt ) {
    317                 findSingleExpression( whileStmt->condition, indexer );
     322                findIntegralExpression( whileStmt->condition, indexer );
    318323        }
    319324
    320325        void Resolver::previsit( ForStmt *forStmt ) {
    321326                if ( forStmt->condition ) {
    322                         findSingleExpression( forStmt->condition, indexer );
     327                        findIntegralExpression( forStmt->condition, indexer );
    323328                } // if
    324329
    … …  
    579584        }
    580585
     586
    581587        void Resolver::previsit( WithStmt * withStmt ) {
    582588                for ( Expression *& expr : withStmt->exprs )  {
    583                         TypeEnvironment env;
    584                         AlternativeFinder finder( indexer, env );
    585                         finder.findWithAdjustment( expr );
    586 
    587589                        // only struct- and union-typed expressions are viable candidates
    588                         AltList candidates;
    589                         for ( Alternative & alt : finder.get_alternatives() ) {
    590                                 if ( isStructOrUnion( alt.expr->result ) ) {
    591                                         candidates.push_back( std::move( alt ) );
    592                                 }
    593                         }
    594 
    595                         // choose the lowest cost expression among the candidates
    596                         AltList winners;
    597                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
    598                         if ( winners.size() == 0 ) {
    599                                 throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
    600                         } else if ( winners.size() != 1 ) {
    601                                 std::ostringstream stream;
    602                                 stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
    603                                 expr->print( stream );
    604                                 stream << "Alternatives are:\n";
    605                                 printAlts( winners, stream, 1 );
    606                                 throw SemanticError( stream.str() );
    607                         }
    608 
    609                         // there is one unambiguous interpretation - move the expression into the with statement
    610                         Alternative & alt = winners.front();
    611                         finishExpr( alt.expr, alt.env, expr->env );
    612                         delete expr;
    613                         expr = alt.expr;
    614                         alt.expr = nullptr;
     590                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
    615591
    616592                        // if with expression might be impure, create a temporary so that it is evaluated once

  • src/ResolvExpr/Resolver.h

    rb158d8f rb6838214  
    3333        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
    3434        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
     35        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer &indexer );
    3536        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
    3637        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

  • src/ResolvExpr/Unify.cc

    rb158d8f rb6838214  
    4444namespace ResolvExpr {
    4545
    46         class Unify : public Visitor {
    47           public:
     46        struct Unify : public WithShortCircuiting {
    4847                Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
    4948
    5049                bool get_result() const { return result; }
     50
     51                void previsit( BaseSyntaxNode * ) { visit_children = false; }
     52
     53                void postvisit( VoidType * voidType );
     54                void postvisit( BasicType * basicType );
     55                void postvisit( PointerType * pointerType );
     56                void postvisit( ArrayType * arrayType );
     57                void postvisit( ReferenceType * refType );
     58                void postvisit( FunctionType * functionType );
     59                void postvisit( StructInstType * aggregateUseType );
     60                void postvisit( UnionInstType * aggregateUseType );
     61                void postvisit( EnumInstType * aggregateUseType );
     62                void postvisit( TraitInstType * aggregateUseType );
     63                void postvisit( TypeInstType * aggregateUseType );
     64                void postvisit( TupleType * tupleType );
     65                void postvisit( VarArgsType * varArgsType );
     66                void postvisit( ZeroType * zeroType );
     67                void postvisit( OneType * oneType );
     68
    5169          private:
    52                 virtual void visit(VoidType *voidType);
    53                 virtual void visit(BasicType *basicType);
    54                 virtual void visit(PointerType *pointerType);
    55                 virtual void visit(ArrayType *arrayType);
    56                 virtual void visit(ReferenceType *refType);
    57                 virtual void visit(FunctionType *functionType);
    58                 virtual void visit(StructInstType *aggregateUseType);
    59                 virtual void visit(UnionInstType *aggregateUseType);
    60                 virtual void visit(EnumInstType *aggregateUseType);
    61                 virtual void visit(TraitInstType *aggregateUseType);
    62                 virtual void visit(TypeInstType *aggregateUseType);
    63                 virtual void visit(TupleType *tupleType);
    64                 virtual void visit(VarArgsType *varArgsType);
    65                 virtual void visit(ZeroType *zeroType);
    66                 virtual void visit(OneType *oneType);
    67 
    6870                template< typename RefType > void handleRefType( RefType *inst, Type *other );
    6971                template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
    … …  
    325327                        result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    326328                } else {
    327                         Unify comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
     329                        PassVisitor<Unify> comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
    328330                        type1->accept( comparator );
    329                         result = comparator.get_result();
     331                        result = comparator.pass.get_result();
    330332                } // if
    331333#ifdef DEBUG
    … …  
    404406        }
    405407
    406         void Unify::visit( __attribute__((unused)) VoidType *voidType) {
     408        void Unify::postvisit( __attribute__((unused)) VoidType *voidType) {
    407409                result = dynamic_cast< VoidType* >( type2 );
    408410        }
    409411
    410         void Unify::visit(BasicType *basicType) {
     412        void Unify::postvisit(BasicType *basicType) {
    411413                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
    412414                        result = basicType->get_kind() == otherBasic->get_kind();
    … …  
    436438        }
    437439
    438         void Unify::visit(PointerType *pointerType) {
     440        void Unify::postvisit(PointerType *pointerType) {
    439441                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
    440442                        result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    … …  
    444446        }
    445447
    446         void Unify::visit(ReferenceType *refType) {
     448        void Unify::postvisit(ReferenceType *refType) {
    447449                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
    448450                        result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    … …  
    452454        }
    453455
    454         void Unify::visit(ArrayType *arrayType) {
     456        void Unify::postvisit(ArrayType *arrayType) {
    455457                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
    456458                // to unify, array types must both be VLA or both not VLA
    … …  
    567569        }
    568570
    569         void Unify::visit(FunctionType *functionType) {
     571        void Unify::postvisit(FunctionType *functionType) {
    570572                FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
    571573                if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
    … …  
    669671        }
    670672
    671         void Unify::visit(StructInstType *structInst) {
     673        void Unify::postvisit(StructInstType *structInst) {
    672674                handleGenericRefType( structInst, type2 );
    673675        }
    674676
    675         void Unify::visit(UnionInstType *unionInst) {
     677        void Unify::postvisit(UnionInstType *unionInst) {
    676678                handleGenericRefType( unionInst, type2 );
    677679        }
    678680
    679         void Unify::visit(EnumInstType *enumInst) {
     681        void Unify::postvisit(EnumInstType *enumInst) {
    680682                handleRefType( enumInst, type2 );
    681683        }
    682684
    683         void Unify::visit(TraitInstType *contextInst) {
     685        void Unify::postvisit(TraitInstType *contextInst) {
    684686                handleRefType( contextInst, type2 );
    685687        }
    686688
    687         void Unify::visit(TypeInstType *typeInst) {
     689        void Unify::postvisit(TypeInstType *typeInst) {
    688690                assert( openVars.find( typeInst->get_name() ) == openVars.end() );
    689691                TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
    … …  
    740742        }
    741743
    742         void Unify::visit(TupleType *tupleType) {
     744        void Unify::postvisit(TupleType *tupleType) {
    743745                if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
    744746                        std::unique_ptr<TupleType> flat1( tupleType->clone() );
    … …  
    757759        }
    758760
    759         void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) {
     761        void Unify::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
    760762                result = dynamic_cast< VarArgsType* >( type2 );
    761763        }
    762764
    763         void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) {
     765        void Unify::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
    764766                result = dynamic_cast< ZeroType* >( type2 );
    765767        }
    766768
    767         void Unify::visit( __attribute__((unused)) OneType *oneType ) {
     769        void Unify::postvisit( __attribute__((unused)) OneType *oneType ) {
    768770                result = dynamic_cast< OneType* >( type2 );
    769771        }

  • src/SymTab/Indexer.cc

    rb158d8f rb6838214  
    572572        }
    573573
     574        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr ) {
     575                for ( Declaration * decl : aggr->members ) {
     576                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
     577                                addId( dwt, expr );
     578                                if ( dwt->name == "" ) {
     579                                        Type * t = dwt->get_type()->stripReferences();
     580                                        if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
     581                                                Expression * base = expr->clone();
     582                                                ResolvExpr::referenceToRvalueConversion( base );
     583                                                addMembers( t->getAggr(), new MemberExpr( dwt, base ) );
     584                                        }
     585                                }
     586                        }
     587                }
     588        }
     589
    574590        void Indexer::addWith( WithStmt * stmt ) {
    575591                for ( Expression * expr : stmt->exprs ) {
    … …  
    578594                                assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
    579595
    580                                 for ( Declaration * decl : aggr->members ) {
    581                                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
    582                                                 addId( dwt, expr );
    583                                         }
    584                                 }
     596                                addMembers( aggr, expr );
    585597                        }
    586598                }

  • src/SymTab/Indexer.h

    rb158d8f rb6838214  
    8686                void addWith( WithStmt * );
    8787
     88                /// adds all of the members of the Aggregate (addWith helper)
     89                void addMembers( AggregateDecl * aggr, Expression * expr );
     90
    8891                /// convenience function for adding a list of Ids to the indexer
    8992                void addIds( const std::list< DeclarationWithType * > & decls );

  • src/SymTab/Mangler.cc

    rb158d8f rb6838214  
    2323
    2424#include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
     25#include "Common/PassVisitor.h"
    2526#include "Common/SemanticError.h"   // for SemanticError
    2627#include "Common/utility.h"         // for toString
    … …  
    3132
    3233namespace SymTab {
    33         std::string Mangler::mangleType( Type * ty ) {
    34                 Mangler mangler( false, true, true );
    35                 maybeAccept( ty, mangler );
    36                 return mangler.get_mangleName();
    37         }
    38 
    39         std::string Mangler::mangleConcrete( Type* ty ) {
    40                 Mangler mangler( false, false, false );
    41                 maybeAccept( ty, mangler );
    42                 return mangler.get_mangleName();
    43         }
    44 
    45         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
    46                 : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
    47 
    48         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
    49                 varNums = rhs.varNums;
    50                 nextVarNum = rhs.nextVarNum;
    51                 isTopLevel = rhs.isTopLevel;
    52                 mangleOverridable = rhs.mangleOverridable;
    53                 typeMode = rhs.typeMode;
    54         }
    55 
    56         void Mangler::mangleDecl( DeclarationWithType * declaration ) {
    57                 bool wasTopLevel = isTopLevel;
    58                 if ( isTopLevel ) {
    59                         varNums.clear();
    60                         nextVarNum = 0;
    61                         isTopLevel = false;
    62                 } // if
    63                 mangleName << "__";
    64                 CodeGen::OperatorInfo opInfo;
    65                 if ( operatorLookup( declaration->get_name(), opInfo ) ) {
    66                         mangleName << opInfo.outputName;
    67                 } else {
    68                         mangleName << declaration->get_name();
    69                 } // if
    70                 mangleName << "__";
    71                 maybeAccept( declaration->get_type(), *this );
    72                 if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
    73                         // want to be able to override autogenerated and intrinsic routines,
    74                         // so they need a different name mangling
    75                         if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
    76                                 mangleName << "autogen__";
    77                         } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
    78                                 mangleName << "intrinsic__";
    79                         } else {
    80                                 // if we add another kind of overridable function, this has to change
    81                                 assert( false && "unknown overrideable linkage" );
    82                         } // if
     34        namespace Mangler {
     35                namespace {
     36                        /// Mangles names to a unique C identifier
     37                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> {
     38                                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
     39                                Mangler( const Mangler & );
     40
     41                                void previsit( BaseSyntaxNode * ) { visit_children = false; }
     42
     43                                void postvisit( ObjectDecl * declaration );
     44                                void postvisit( FunctionDecl * declaration );
     45                                void postvisit( TypeDecl * declaration );
     46
     47                                void postvisit( VoidType * voidType );
     48                                void postvisit( BasicType * basicType );
     49                                void postvisit( PointerType * pointerType );
     50                                void postvisit( ArrayType * arrayType );
     51                                void postvisit( ReferenceType * refType );
     52                                void postvisit( FunctionType * functionType );
     53                                void postvisit( StructInstType * aggregateUseType );
     54                                void postvisit( UnionInstType * aggregateUseType );
     55                                void postvisit( EnumInstType * aggregateUseType );
     56                                void postvisit( TypeInstType * aggregateUseType );
     57                                void postvisit( TupleType * tupleType );
     58                                void postvisit( VarArgsType * varArgsType );
     59                                void postvisit( ZeroType * zeroType );
     60                                void postvisit( OneType * oneType );
     61
     62                                std::string get_mangleName() { return mangleName.str(); }
     63                          private:
     64                                std::ostringstream mangleName;  ///< Mangled name being constructed
     65                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
     66                                VarMapType varNums;             ///< Map of type variables to indices
     67                                int nextVarNum;                 ///< Next type variable index
     68                                bool isTopLevel;                ///< Is the Mangler at the top level
     69                                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
     70                                bool typeMode;                  ///< Produce a unique mangled name for a type
     71                                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
     72
     73                                void mangleDecl( DeclarationWithType *declaration );
     74                                void mangleRef( ReferenceToType *refType, std::string prefix );
     75
     76                                void printQualifiers( Type *type );
     77                        }; // Mangler
     78                } // namespace
     79
     80                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
     81                        PassVisitor<Mangler> mangler( mangleOverridable, typeMode, mangleGenericParams );
     82                        maybeAccept( decl, mangler );
     83                        return mangler.pass.get_mangleName();
    8384                }
    84                 isTopLevel = wasTopLevel;
    85         }
    86 
    87         void Mangler::visit( ObjectDecl * declaration ) {
    88                 mangleDecl( declaration );
    89         }
    90 
    91         void Mangler::visit( FunctionDecl * declaration ) {
    92                 mangleDecl( declaration );
    93         }
    94 
    95         void Mangler::visit( VoidType * voidType ) {
    96                 printQualifiers( voidType );
    97                 mangleName << "v";
    98         }
    99 
    100         void Mangler::visit( BasicType * basicType ) {
    101                 static const char *btLetter[] = {
    102                         "b",    // Bool
    103                         "c",    // Char
    104                         "Sc",   // SignedChar
    105                         "Uc",   // UnsignedChar
    106                         "s",    // ShortSignedInt
    107                         "Us",   // ShortUnsignedInt
    108                         "i",    // SignedInt
    109                         "Ui",   // UnsignedInt
    110                         "l",    // LongSignedInt
    111                         "Ul",   // LongUnsignedInt
    112                         "q",    // LongLongSignedInt
    113                         "Uq",   // LongLongUnsignedInt
    114                         "f",    // Float
    115                         "d",    // Double
    116                         "r",    // LongDouble
    117                         "Xf",   // FloatComplex
    118                         "Xd",   // DoubleComplex
    119                         "Xr",   // LongDoubleComplex
    120                         "If",   // FloatImaginary
    121                         "Id",   // DoubleImaginary
    122                         "Ir",   // LongDoubleImaginary
    123                         "w",    // SignedInt128
    124                         "Uw",   // UnsignedInt128
    125                 };
    126 
    127                 printQualifiers( basicType );
    128                 mangleName << btLetter[ basicType->get_kind() ];
    129         }
    130 
    131         void Mangler::visit( PointerType * pointerType ) {
    132                 printQualifiers( pointerType );
    133                 mangleName << "P";
    134                 maybeAccept( pointerType->get_base(), *this );
    135         }
    136 
    137         void Mangler::visit( ArrayType * arrayType ) {
    138                 // TODO: encode dimension
    139                 printQualifiers( arrayType );
    140                 mangleName << "A0";
    141                 maybeAccept( arrayType->get_base(), *this );
    142         }
    143 
    144         void Mangler::visit( ReferenceType * refType ) {
    145                 printQualifiers( refType );
    146                 mangleName << "R";
    147                 maybeAccept( refType->get_base(), *this );
    148         }
    149 
    150         namespace {
    151                 inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
    152                         std::list< Type* > ret;
    153                         std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
    154                                                         std::mem_fun( &DeclarationWithType::get_type ) );
    155                         return ret;
     85
     86                std::string mangleType( Type * ty ) {
     87                        PassVisitor<Mangler> mangler( false, true, true );
     88                        maybeAccept( ty, mangler );
     89                        return mangler.pass.get_mangleName();
    15690                }
    157         }
    158 
    159         void Mangler::visit( FunctionType * functionType ) {
    160                 printQualifiers( functionType );
    161                 mangleName << "F";
    162                 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
    163                 acceptAll( returnTypes, *this );
    164                 mangleName << "_";
    165                 std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
    166                 acceptAll( paramTypes, *this );
    167                 mangleName << "_";
    168         }
    169 
    170         void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
    171                 printQualifiers( refType );
    172 
    173                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
    174 
    175                 if ( mangleGenericParams ) {
    176                         std::list< Expression* >& params = refType->get_parameters();
    177                         if ( ! params.empty() ) {
     91
     92                std::string mangleConcrete( Type * ty ) {
     93                        PassVisitor<Mangler> mangler( false, false, false );
     94                        maybeAccept( ty, mangler );
     95                        return mangler.pass.get_mangleName();
     96                }
     97
     98                namespace {
     99                        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
     100                                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
     101
     102                        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
     103                                varNums = rhs.varNums;
     104                                nextVarNum = rhs.nextVarNum;
     105                                isTopLevel = rhs.isTopLevel;
     106                                mangleOverridable = rhs.mangleOverridable;
     107                                typeMode = rhs.typeMode;
     108                        }
     109
     110                        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
     111                                bool wasTopLevel = isTopLevel;
     112                                if ( isTopLevel ) {
     113                                        varNums.clear();
     114                                        nextVarNum = 0;
     115                                        isTopLevel = false;
     116                                } // if
     117                                mangleName << "__";
     118                                CodeGen::OperatorInfo opInfo;
     119                                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
     120                                        mangleName << opInfo.outputName;
     121                                } else {
     122                                        mangleName << declaration->get_name();
     123                                } // if
     124                                mangleName << "__";
     125                                maybeAccept( declaration->get_type(), *visitor );
     126                                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
     127                                        // want to be able to override autogenerated and intrinsic routines,
     128                                        // so they need a different name mangling
     129                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
     130                                                mangleName << "autogen__";
     131                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
     132                                                mangleName << "intrinsic__";
     133                                        } else {
     134                                                // if we add another kind of overridable function, this has to change
     135                                                assert( false && "unknown overrideable linkage" );
     136                                        } // if
     137                                }
     138                                isTopLevel = wasTopLevel;
     139                        }
     140
     141                        void Mangler::postvisit( ObjectDecl * declaration ) {
     142                                mangleDecl( declaration );
     143                        }
     144
     145                        void Mangler::postvisit( FunctionDecl * declaration ) {
     146                                mangleDecl( declaration );
     147                        }
     148
     149                        void Mangler::postvisit( VoidType * voidType ) {
     150                                printQualifiers( voidType );
     151                                mangleName << "v";
     152                        }
     153
     154                        void Mangler::postvisit( BasicType * basicType ) {
     155                                static const char *btLetter[] = {
     156                                        "b",    // Bool
     157                                        "c",    // Char
     158                                        "Sc",   // SignedChar
     159                                        "Uc",   // UnsignedChar
     160                                        "s",    // ShortSignedInt
     161                                        "Us",   // ShortUnsignedInt
     162                                        "i",    // SignedInt
     163                                        "Ui",   // UnsignedInt
     164                                        "l",    // LongSignedInt
     165                                        "Ul",   // LongUnsignedInt
     166                                        "q",    // LongLongSignedInt
     167                                        "Uq",   // LongLongUnsignedInt
     168                                        "f",    // Float
     169                                        "d",    // Double
     170                                        "r",    // LongDouble
     171                                        "Xf",   // FloatComplex
     172                                        "Xd",   // DoubleComplex
     173                                        "Xr",   // LongDoubleComplex
     174                                        "If",   // FloatImaginary
     175                                        "Id",   // DoubleImaginary
     176                                        "Ir",   // LongDoubleImaginary
     177                                        "w",    // SignedInt128
     178                                        "Uw",   // UnsignedInt128
     179                                };
     180
     181                                printQualifiers( basicType );
     182                                mangleName << btLetter[ basicType->get_kind() ];
     183                        }
     184
     185                        void Mangler::postvisit( PointerType * pointerType ) {
     186                                printQualifiers( pointerType );
     187                                mangleName << "P";
     188                                maybeAccept( pointerType->get_base(), *visitor );
     189                        }
     190
     191                        void Mangler::postvisit( ArrayType * arrayType ) {
     192                                // TODO: encode dimension
     193                                printQualifiers( arrayType );
     194                                mangleName << "A0";
     195                                maybeAccept( arrayType->get_base(), *visitor );
     196                        }
     197
     198                        void Mangler::postvisit( ReferenceType * refType ) {
     199                                printQualifiers( refType );
     200                                mangleName << "R";
     201                                maybeAccept( refType->get_base(), *visitor );
     202                        }
     203
     204                        namespace {
     205                                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
     206                                        std::list< Type* > ret;
     207                                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
     208                                                                        std::mem_fun( &DeclarationWithType::get_type ) );
     209                                        return ret;
     210                                }
     211                        }
     212
     213                        void Mangler::postvisit( FunctionType * functionType ) {
     214                                printQualifiers( functionType );
     215                                mangleName << "F";
     216                                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
     217                                acceptAll( returnTypes, *visitor );
    178218                                mangleName << "_";
    179                                 for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
    180                                         TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    181                                         assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
    182                                         maybeAccept( paramType->get_type(), *this );
     219                                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
     220                                acceptAll( paramTypes, *visitor );
     221                                mangleName << "_";
     222                        }
     223
     224                        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
     225                                printQualifiers( refType );
     226
     227                                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
     228
     229                                if ( mangleGenericParams ) {
     230                                        std::list< Expression* >& params = refType->get_parameters();
     231                                        if ( ! params.empty() ) {
     232                                                mangleName << "_";
     233                                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
     234                                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
     235                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
     236                                                        maybeAccept( paramType->get_type(), *visitor );
     237                                                }
     238                                                mangleName << "_";
     239                                        }
    183240                                }
     241                        }
     242
     243                        void Mangler::postvisit( StructInstType * aggregateUseType ) {
     244                                mangleRef( aggregateUseType, "s" );
     245                        }
     246
     247                        void Mangler::postvisit( UnionInstType * aggregateUseType ) {
     248                                mangleRef( aggregateUseType, "u" );
     249                        }
     250
     251                        void Mangler::postvisit( EnumInstType * aggregateUseType ) {
     252                                mangleRef( aggregateUseType, "e" );
     253                        }
     254
     255                        void Mangler::postvisit( TypeInstType * typeInst ) {
     256                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
     257                                if ( varNum == varNums.end() ) {
     258                                        mangleRef( typeInst, "t" );
     259                                } else {
     260                                        printQualifiers( typeInst );
     261                                        std::ostringstream numStream;
     262                                        numStream << varNum->second.first;
     263                                        switch ( (TypeDecl::Kind )varNum->second.second ) {
     264                                          case TypeDecl::Dtype:
     265                                                mangleName << "d";
     266                                                break;
     267                                          case TypeDecl::Ftype:
     268                                                mangleName << "f";
     269                                                break;
     270                                                case TypeDecl::Ttype:
     271                                                mangleName << "tVARGS";
     272                                                break;
     273                                                default:
     274                                                assert( false );
     275                                        } // switch
     276                                        mangleName << numStream.str();
     277                                } // if
     278                        }
     279
     280                        void Mangler::postvisit( TupleType * tupleType ) {
     281                                printQualifiers( tupleType );
     282                                mangleName << "T";
     283                                acceptAll( tupleType->types, *visitor );
    184284                                mangleName << "_";
    185285                        }
    186                 }
    187         }
    188 
    189         void Mangler::visit( StructInstType * aggregateUseType ) {
    190                 mangleRef( aggregateUseType, "s" );
    191         }
    192 
    193         void Mangler::visit( UnionInstType * aggregateUseType ) {
    194                 mangleRef( aggregateUseType, "u" );
    195         }
    196 
    197         void Mangler::visit( EnumInstType * aggregateUseType ) {
    198                 mangleRef( aggregateUseType, "e" );
    199         }
    200 
    201         void Mangler::visit( TypeInstType * typeInst ) {
    202                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
    203                 if ( varNum == varNums.end() ) {
    204                         mangleRef( typeInst, "t" );
    205                 } else {
    206                         printQualifiers( typeInst );
    207                         std::ostringstream numStream;
    208                         numStream << varNum->second.first;
    209                         switch ( (TypeDecl::Kind )varNum->second.second ) {
    210                           case TypeDecl::Dtype:
    211                                 mangleName << "d";
    212                                 break;
    213                           case TypeDecl::Ftype:
    214                                 mangleName << "f";
    215                                 break;
    216                                 case TypeDecl::Ttype:
    217                                 mangleName << "tVARGS";
    218                                 break;
    219                                 default:
    220                                 assert( false );
    221                         } // switch
    222                         mangleName << numStream.str();
    223                 } // if
    224         }
    225 
    226         void Mangler::visit( TupleType * tupleType ) {
    227                 printQualifiers( tupleType );
    228                 mangleName << "T";
    229                 acceptAll( tupleType->types, *this );
    230                 mangleName << "_";
    231         }
    232 
    233         void Mangler::visit( VarArgsType * varArgsType ) {
    234                 printQualifiers( varArgsType );
    235                 mangleName << "VARGS";
    236         }
    237 
    238         void Mangler::visit( ZeroType * ) {
    239                 mangleName << "Z";
    240         }
    241 
    242         void Mangler::visit( OneType * ) {
    243                 mangleName << "O";
    244         }
    245 
    246         void Mangler::visit( TypeDecl * decl ) {
    247                 static const char *typePrefix[] = { "BT", "BD", "BF" };
    248                 mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
    249         }
    250 
    251         void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
    252                 for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
    253                         os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
    254                 } // for
    255         }
    256 
    257         void Mangler::printQualifiers( Type * type ) {
    258                 // skip if not including qualifiers
    259                 if ( typeMode ) return;
    260 
    261                 if ( ! type->get_forall().empty() ) {
    262                         std::list< std::string > assertionNames;
    263                         int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
    264                         mangleName << "A";
    265                         for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
    266                                 switch ( (*i)->get_kind() ) {
    267                                   case TypeDecl::Dtype:
    268                                         dcount++;
    269                                         break;
    270                                   case TypeDecl::Ftype:
    271                                         fcount++;
    272                                         break;
    273                                   case TypeDecl::Ttype:
    274                                         vcount++;
    275                                         break;
    276                                   default:
    277                                         assert( false );
    278                                 } // switch
    279                                 varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
    280                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
    281                                         Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
    282                                         sub_mangler.nextVarNum = nextVarNum;
    283                                         sub_mangler.isTopLevel = false;
    284                                         sub_mangler.varNums = varNums;
    285                                         (*assert)->accept( sub_mangler );
    286                                         assertionNames.push_back( sub_mangler.mangleName.str() );
     286
     287                        void Mangler::postvisit( VarArgsType * varArgsType ) {
     288                                printQualifiers( varArgsType );
     289                                mangleName << "VARGS";
     290                        }
     291
     292                        void Mangler::postvisit( ZeroType * ) {
     293                                mangleName << "Z";
     294                        }
     295
     296                        void Mangler::postvisit( OneType * ) {
     297                                mangleName << "O";
     298                        }
     299
     300                        void Mangler::postvisit( TypeDecl * decl ) {
     301                                static const char *typePrefix[] = { "BT", "BD", "BF" };
     302                                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
     303                        }
     304
     305                        __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
     306                                for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
     307                                        os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
    287308                                } // for
    288                         } // for
    289                         mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
    290                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    291                         mangleName << "_";
    292                 } // if
    293                 if ( type->get_const() ) {
    294                         mangleName << "C";
    295                 } // if
    296                 if ( type->get_volatile() ) {
    297                         mangleName << "V";
    298                 } // if
    299                 if ( type->get_mutex() ) {
    300                         mangleName << "M";
    301                 } // if
    302                 // Removed due to restrict not affecting function compatibility in GCC
    303 //              if ( type->get_isRestrict() ) {
    304 //                      mangleName << "E";
    305 //              } // if
    306                 if ( type->get_lvalue() ) {
    307                         // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
    308                         mangleName << "L";
    309                 }
    310                 if ( type->get_atomic() ) {
    311                         mangleName << "A";
    312                 } // if
    313         }
     309                        }
     310
     311                        void Mangler::printQualifiers( Type * type ) {
     312                                // skip if not including qualifiers
     313                                if ( typeMode ) return;
     314
     315                                if ( ! type->get_forall().empty() ) {
     316                                        std::list< std::string > assertionNames;
     317                                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
     318                                        mangleName << "A";
     319                                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
     320                                                switch ( (*i)->get_kind() ) {
     321                                                  case TypeDecl::Dtype:
     322                                                        dcount++;
     323                                                        break;
     324                                                  case TypeDecl::Ftype:
     325                                                        fcount++;
     326                                                        break;
     327                                                  case TypeDecl::Ttype:
     328                                                        vcount++;
     329                                                        break;
     330                                                  default:
     331                                                        assert( false );
     332                                                } // switch
     333                                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
     334                                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
     335                                                        PassVisitor<Mangler> sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
     336                                                        sub_mangler.pass.nextVarNum = nextVarNum;
     337                                                        sub_mangler.pass.isTopLevel = false;
     338                                                        sub_mangler.pass.varNums = varNums;
     339                                                        (*assert)->accept( sub_mangler );
     340                                                        assertionNames.push_back( sub_mangler.pass.mangleName.str() );
     341                                                } // for
     342                                        } // for
     343                                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
     344                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
     345                                        mangleName << "_";
     346                                } // if
     347                                if ( type->get_const() ) {
     348                                        mangleName << "C";
     349                                } // if
     350                                if ( type->get_volatile() ) {
     351                                        mangleName << "V";
     352                                } // if
     353                                if ( type->get_mutex() ) {
     354                                        mangleName << "M";
     355                                } // if
     356                                // Removed due to restrict not affecting function compatibility in GCC
     357                //              if ( type->get_isRestrict() ) {
     358                //                      mangleName << "E";
     359                //              } // if
     360                                if ( type->get_lvalue() ) {
     361                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
     362                                        mangleName << "L";
     363                                }
     364                                if ( type->get_atomic() ) {
     365                                        mangleName << "A";
     366                                } // if
     367                        }
     368                }       // namespace
     369        } // namespace Mangler
    314370} // namespace SymTab
    315371

  • src/SymTab/Mangler.h

    rb158d8f rb6838214  
    2525
    2626namespace SymTab {
    27         /// Mangles names to a unique C identifier
    28         class Mangler : public Visitor {
    29           public:
     27        namespace Mangler {
    3028                /// Mangle syntax tree object; primary interface to clients
    31                 template< typename SynTreeClass >
    32             static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
     29                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
     30
    3331                /// Mangle a type name; secondary interface
    34                 static std::string mangleType( Type* ty );
     32                std::string mangleType( Type* ty );
    3533                /// Mangle ignoring generic type parameters
    36                 static std::string mangleConcrete( Type* ty );
    37 
    38 
    39                 virtual void visit( ObjectDecl *declaration );
    40                 virtual void visit( FunctionDecl *declaration );
    41                 virtual void visit( TypeDecl *declaration );
    42 
    43                 virtual void visit( VoidType *voidType );
    44                 virtual void visit( BasicType *basicType );
    45                 virtual void visit( PointerType *pointerType );
    46                 virtual void visit( ArrayType *arrayType );
    47                 virtual void visit( ReferenceType *refType );
    48                 virtual void visit( FunctionType *functionType );
    49                 virtual void visit( StructInstType *aggregateUseType );
    50                 virtual void visit( UnionInstType *aggregateUseType );
    51                 virtual void visit( EnumInstType *aggregateUseType );
    52                 virtual void visit( TypeInstType *aggregateUseType );
    53                 virtual void visit( TupleType *tupleType );
    54                 virtual void visit( VarArgsType *varArgsType );
    55                 virtual void visit( ZeroType *zeroType );
    56                 virtual void visit( OneType *oneType );
    57 
    58                 std::string get_mangleName() { return mangleName.str(); }
    59           private:
    60                 std::ostringstream mangleName;  ///< Mangled name being constructed
    61                 typedef std::map< std::string, std::pair< int, int > > VarMapType;
    62                 VarMapType varNums;             ///< Map of type variables to indices
    63                 int nextVarNum;                 ///< Next type variable index
    64                 bool isTopLevel;                ///< Is the Mangler at the top level
    65                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
    66                 bool typeMode;                  ///< Produce a unique mangled name for a type
    67                 bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
    68 
    69                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
    70                 Mangler( const Mangler & );
    71 
    72                 void mangleDecl( DeclarationWithType *declaration );
    73                 void mangleRef( ReferenceToType *refType, std::string prefix );
    74 
    75                 void printQualifiers( Type *type );
    76         }; // Mangler
    77 
    78         template< typename SynTreeClass >
    79         std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
    80                 Mangler mangler( mangleOverridable, typeMode, mangleGenericParams );
    81                 maybeAccept( decl, mangler );
    82                 return mangler.get_mangleName();
    83         }
     34                std::string mangleConcrete( Type* ty );
     35        } // Mangler
    8436} // SymTab
    8537

  • src/SymTab/Validate.cc

    rb158d8f rb6838214  
    9494                template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
    9595
    96                 bool inStruct = false;
     96                AggregateDecl * parentAggr = nullptr;
    9797        };
    9898
    … …  
    303303        template< typename AggDecl >
    304304        void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
    305                 if ( inStruct ) {
     305                if ( parentAggr ) {
    306306                        // Add elements in stack order corresponding to nesting structure.
    307307                        declsToAddBefore.push_front( aggregateDecl );
    308308                } else {
    309                         GuardValue( inStruct );
    310                         inStruct = true;
     309                        GuardValue( parentAggr );
     310                        parentAggr = aggregateDecl;
    311311                } // if
    312312                // Always remove the hoisted aggregate from the inner structure.
    … …  
    754754                                throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
    755755                        }
    756                         // cannot redefine VLA typedefs
     756                        // Cannot redefine VLA typedefs. Note: this is slightly incorrect, because our notion of VLAs
     757                        // at this point in the translator is imprecise. In particular, this will disallow redefining typedefs
     758                        // with arrays whose dimension is an enumerator or a cast of a constant/enumerator. The effort required
     759                        // to fix this corner case likely outweighs the utility of allowing it.
    757760                        if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) {
    758761                                throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );

  • src/SynTree/AggregateDecl.cc

    rb158d8f rb6838214  
    8686std::string TraitDecl::typeString() const { return "trait"; }
    8787
     88namespace {
     89        long long int getConstValue( Expression * expr ) {
     90                if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
     91                        return getConstValue( castExpr->arg );
     92                } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
     93                        return constExpr->intValue();
     94                // can be -1, +1, etc.
     95                // } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
     96                //      if ( untypedExpr-> )
     97                } else {
     98                        assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() );
     99                }
     100        }
     101}
     102
     103bool EnumDecl::valueOf( Declaration * enumerator, long long int & value ) {
     104        if ( enumValues.empty() ) {
     105                long long int currentValue = 0;
     106                for ( Declaration * member : members ) {
     107                        ObjectDecl * field = strict_dynamic_cast< ObjectDecl * >( member );
     108                        if ( field->init ) {
     109                                SingleInit * init = strict_dynamic_cast< SingleInit * >( field->init );
     110                                currentValue = getConstValue( init->value );
     111                        }
     112                        assertf( enumValues.count( field->name ) == 0, "Enum %s has multiple members with the name %s", name.c_str(), field->name.c_str() );
     113                        enumValues[ field->name ] = currentValue;
     114                        ++currentValue;
     115                }
     116        }
     117        if ( enumValues.count( enumerator->name ) ) {
     118                value = enumValues[ enumerator->name ];
     119                return true;
     120        }
     121        return false;
     122}
     123
    88124// Local Variables: //
    89125// tab-width: 4 //

  • src/SynTree/CompoundStmt.cc

    rb158d8f rb6838214  
    6464        }
    6565        if ( ! declMap.empty() ) {
    66                 VarExprReplacer replacer( declMap );
    67                 accept( replacer );
     66                VarExprReplacer::replace( this, declMap );
    6867        }
    6968}

  • src/SynTree/Declaration.h

    rb158d8f rb6838214  
    319319        EnumDecl( const EnumDecl &other ) : Parent( other ) {}
    320320
     321        bool valueOf( Declaration * enumerator, long long int & value );
     322
    321323        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
    322324        virtual void accept( Visitor &v ) override { v.visit( this ); }
    323325        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
    324326  private:
     327        std::map< std::string, long long int > enumValues;
    325328        virtual std::string typeString() const override;
    326329};

  • src/SynTree/Expression.cc

    rb158d8f rb6838214  
    8383}
    8484
     85long long int ConstantExpr::intValue() const {
     86        if ( BasicType * basicType = dynamic_cast< BasicType * >( result ) ) {
     87                if ( basicType->isInteger() ) {
     88                        return get_constant()->get_ival();
     89                }
     90        } else if ( dynamic_cast< OneType * >( result ) ) {
     91                return 1;
     92        } else if ( dynamic_cast< ZeroType * >( result ) ) {
     93                return 0;
     94        }
     95        throw SemanticError( "Constant expression of non-integral type ", this );
     96}
     97
    8598VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
    8699        assert( var );
    … …  
    95108        //      assert( inst->baseEnum );
    96109        //      EnumDecl * decl = inst->baseEnum;
    97         //      for ( Declaration * member : decl->members ) {
    98         //              if ( member == _var ) {
    99         //                      type->set_lvalue( false );
    100         //              }
     110        //      long long int value;
     111        //      if ( decl->valueOf( var, value ) ) {
     112        //              type->set_lvalue( false );
    101113        //      }
    102114        // }
    … …  
    403415                } else {
    404416                        // references have been removed, in which case dereference returns an lvalue of the base type.
    405                         ret->get_result()->set_lvalue( true );
     417                        ret->result->set_lvalue( true );
    406418                }
    407419        }
    … …  
    589601        if ( ! body.empty() ) {
    590602                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
    591                         set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
     603                        result = maybeClone( exprStmt->expr->result );
    592604                }
    593605        }
    594606        // ensure that StmtExpr has a result type
    595607        if ( ! result ) {
    596                 set_result( new VoidType( Type::Qualifiers() ) );
     608                result = new VoidType( Type::Qualifiers() );
    597609        }
    598610}

  • src/SynTree/Expression.h

    rb158d8f rb6838214  
    295295
    296296        Constant * get_constant() { return & constant; }
     297        const Constant * get_constant() const { return & constant; }
    297298        void set_constant( const Constant & newValue ) { constant = newValue; }
     299
     300        long long int intValue() const;
    298301
    299302        virtual ConstantExpr * clone() const { return new ConstantExpr( * this ); }

  • src/SynTree/FunctionDecl.cc

    rb158d8f rb6838214  
    4949        }
    5050        if ( ! declMap.empty() ) {
    51                 VarExprReplacer replacer( declMap );
    52                 accept( replacer );
     51                VarExprReplacer::replace( this, declMap );
    5352        }
    5453}

  • src/SynTree/Label.h

    rb158d8f rb6838214  
    3333        std::list< Attribute * >& get_attributes() { return attributes; }
    3434
    35         operator std::string() { return name; }
     35        operator std::string() const { return name; }
    3636        bool empty() { return name.empty(); }
    3737  private:

  • src/SynTree/Type.h

    rb158d8f rb6838214  
    356356        bool isTtype() const;
    357357
     358        bool isUnprototyped() const { return isVarArgs && parameters.size() == 0; }
     359
    358360        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
    359361        virtual void accept( Visitor & v ) override { v.visit( this ); }

  • src/SynTree/TypeSubstitution.cc

    rb158d8f rb6838214  
    107107
    108108void TypeSubstitution::normalize() {
     109        PassVisitor<Substituter> sub( *this, true );
    109110        do {
    110                 subCount = 0;
    111                 freeOnly = true;
     111                sub.pass.subCount = 0;
     112                sub.pass.freeOnly = true;
    112113                for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
    113                         i->second = i->second->acceptMutator( *this );
     114                        i->second = i->second->acceptMutator( sub );
    114115                }
    115         } while ( subCount );
    116 }
    117 
    118 Type * TypeSubstitution::mutate( TypeInstType *inst ) {
    119         BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() );
     116        } while ( sub.pass.subCount );
     117}
     118
     119Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
     120        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
    120121        if ( bound != boundVars.end() ) return inst;
    121122
    122         TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );
    123         if ( i == typeEnv.end() ) {
     123        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->get_name() );
     124        if ( i == sub.typeEnv.end() ) {
    124125                return inst;
    125126        } else {
    126 ///         std::cout << "found " << inst->get_name() << ", replacing with ";
    127 ///         i->second->print( std::cout );
    128 ///         std::cout << std::endl;
     127///         std::cerr << "found " << inst->get_name() << ", replacing with ";
     128///         i->second->print( std::cerr );
     129///         std::cerr << std::endl;
    129130                subCount++;
    130                 Type *newtype = i->second->clone();
     131                Type * newtype = i->second->clone();
    131132                newtype->get_qualifiers() |= inst->get_qualifiers();
    132133                delete inst;
    … …  
    135136}
    136137
    137 Expression * TypeSubstitution::mutate( NameExpr *nameExpr ) {
    138         VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name() );
    139         if ( i == varEnv.end() ) {
     138Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) {
     139        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
     140        if ( i == sub.varEnv.end() ) {
    140141                return nameExpr;
    141142        } else {
    … …  
    146147}
    147148
    148 template< typename TypeClass >
    149 Type *TypeSubstitution::handleType( TypeClass *type ) {
    150         ValueGuard<BoundVarsType> oldBoundVars( boundVars );
     149void TypeSubstitution::Substituter::premutate( Type * type ) {
     150        GuardValue( boundVars );
    151151        // bind type variables from forall-qualifiers
    152152        if ( freeOnly ) {
    153                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
    154                         boundVars.insert( (*tyvar )->get_name() );
     153                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
     154                        boundVars.insert( (*tyvar)->name );
    155155                } // for
    156156        } // if
    157         Type *ret = Mutator::mutate( type );
    158         return ret;
    159157}
    160158
    161159template< typename TypeClass >
    162 Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {
    163         ValueGuard<BoundVarsType> oldBoundVars( boundVars );
     160void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
     161        GuardValue( boundVars );
    164162        // bind type variables from forall-qualifiers
    165163        if ( freeOnly ) {
    166                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
    167                         boundVars.insert( (*tyvar )->get_name() );
     164                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
     165                        boundVars.insert( (*tyvar)->name );
    168166                } // for
    169167                // bind type variables from generic type instantiations
    170168                std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
    171                 if ( baseParameters && ! type->get_parameters().empty() ) {
     169                if ( baseParameters && ! type->parameters.empty() ) {
    172170                        for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
    173                                 boundVars.insert( (*tyvar)->get_name() );
     171                                boundVars.insert( (*tyvar)->name );
    174172                        } // for
    175173                } // if
    176174        } // if
    177         Type *ret = Mutator::mutate( type );
    178         return ret;
    179 }
    180 
    181 Type * TypeSubstitution::mutate( VoidType *voidType ) {
    182         return handleType( voidType );
    183 }
    184 
    185 Type * TypeSubstitution::mutate( BasicType *basicType ) {
    186         return handleType( basicType );
    187 }
    188 
    189 Type * TypeSubstitution::mutate( PointerType *pointerType ) {
    190         return handleType( pointerType );
    191 }
    192 
    193 Type * TypeSubstitution::mutate( ArrayType *arrayType ) {
    194         return handleType( arrayType );
    195 }
    196 
    197 Type * TypeSubstitution::mutate( FunctionType *functionType ) {
    198         return handleType( functionType );
    199 }
    200 
    201 Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) {
    202         return handleAggregateType( aggregateUseType );
    203 }
    204 
    205 Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) {
    206         return handleAggregateType( aggregateUseType );
    207 }
    208 
    209 Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) {
    210         return handleType( aggregateUseType );
    211 }
    212 
    213 Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) {
    214         return handleType( aggregateUseType );
    215 }
    216 
    217 Type * TypeSubstitution::mutate( TupleType *tupleType ) {
    218         return handleType( tupleType );
    219 }
    220 
    221 Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
    222         return handleType( varArgsType );
    223 }
    224 
    225 Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
    226         return handleType( zeroType );
    227 }
    228 
    229 Type * TypeSubstitution::mutate( OneType *oneType ) {
    230         return handleType( oneType );
     175}
     176
     177void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) {
     178        handleAggregateType( aggregateUseType );
     179}
     180
     181void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
     182        handleAggregateType( aggregateUseType );
    231183}
    232184

  • src/SynTree/TypeSubstitution.h

    rb158d8f rb6838214  
    2727#include "SynTree/Declaration.h"   // for TypeDecl, Declaration (ptr only)
    2828#include "SynTree/Expression.h"    // for Expression (ptr only), NameExpr (p...
    29 #include "SynTree/Mutator.h"       // for Mutator
    3029#include "SynTree/Type.h"          // for Type, ArrayType (ptr only), BasicT...
    3130
    32 class TypeSubstitution : public Mutator {
    33         typedef Mutator Parent;
     31class TypeSubstitution {
    3432  public:
    3533        TypeSubstitution();
    … …  
    6462        TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
    6563  private:
    66         virtual Type* mutate(TypeInstType *aggregateUseType);
    67         virtual Expression* mutate(NameExpr *nameExpr);
    6864
    69         /// Records type variable bindings from forall-statements
    70         template< typename TypeClass > Type *handleType( TypeClass *type );
    71         /// Records type variable bindings from forall-statements and instantiations of generic types
    72         template< typename TypeClass > Type *handleAggregateType( TypeClass *type );
    73 
    74         virtual Type* mutate(VoidType *basicType);
    75         virtual Type* mutate(BasicType *basicType);
    76         virtual Type* mutate(PointerType *pointerType);
    77         virtual Type* mutate(ArrayType *arrayType);
    78         virtual Type* mutate(FunctionType *functionType);
    79         virtual Type* mutate(StructInstType *aggregateUseType);
    80         virtual Type* mutate(UnionInstType *aggregateUseType);
    81         virtual Type* mutate(EnumInstType *aggregateUseType);
    82         virtual Type* mutate(TraitInstType *aggregateUseType);
    83         virtual Type* mutate(TupleType *tupleType);
    84         virtual Type* mutate(VarArgsType *varArgsType);
    85         virtual Type* mutate(ZeroType *zeroType);
    86         virtual Type* mutate(OneType *oneType);
     65        // Mutator that performs the substitution
     66        struct Substituter;
    8767
    8868        // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
    … …  
    9777        typedef std::map< std::string, Type* > TypeEnvType;
    9878        typedef std::map< std::string, Expression* > VarEnvType;
    99         typedef std::set< std::string > BoundVarsType;
    10079        TypeEnvType typeEnv;
    10180        VarEnvType varEnv;
    102         BoundVarsType boundVars;
    103         int subCount;
    104         bool freeOnly;
    10581};
    10682
    … …  
    134110
    135111template< typename FormalIterator, typename ActualIterator >
    136 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin )
    137 {
     112TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
    138113        add( formalBegin, formalEnd, actualBegin );
    139114}
     115
     116// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
     117// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
     118#include "Common/PassVisitor.h"
     119
     120// definitition must happen after PassVisitor is included so that WithGuards can be used
     121struct TypeSubstitution::Substituter : public WithGuards {
     122                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
     123
     124                Type * postmutate( TypeInstType * aggregateUseType );
     125                Expression * postmutate( NameExpr * nameExpr );
     126
     127                /// Records type variable bindings from forall-statements
     128                void premutate( Type * type );
     129                /// Records type variable bindings from forall-statements and instantiations of generic types
     130                template< typename TypeClass > void handleAggregateType( TypeClass * type );
     131
     132                void premutate( StructInstType * aggregateUseType );
     133                void premutate( UnionInstType * aggregateUseType );
     134
     135                TypeSubstitution & sub;
     136                int subCount = 0;
     137                bool freeOnly;
     138                typedef std::set< std::string > BoundVarsType;
     139                BoundVarsType boundVars;
     140};
    140141
    141142template< typename SynTreeClass >
    142143int TypeSubstitution::apply( SynTreeClass *&input ) {
    143144        assert( input );
    144         subCount = 0;
    145         freeOnly = false;
    146         input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
     145        PassVisitor<Substituter> sub( *this, false );
     146        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
    147147        assert( input );
    148 ///     std::cout << "substitution result is: ";
    149 ///     newType->print( std::cout );
    150 ///     std::cout << std::endl;
    151         return subCount;
     148///     std::cerr << "substitution result is: ";
     149///     newType->print( std::cerr );
     150///     std::cerr << std::endl;
     151        return sub.pass.subCount;
    152152}
    153153
    … …  
    155155int TypeSubstitution::applyFree( SynTreeClass *&input ) {
    156156        assert( input );
    157         subCount = 0;
    158         freeOnly = true;
    159         input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
     157        PassVisitor<Substituter> sub( *this, true );
     158        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
    160159        assert( input );
    161 ///     std::cout << "substitution result is: ";
    162 ///     newType->print( std::cout );
    163 ///     std::cout << std::endl;
    164         return subCount;
     160///     std::cerr << "substitution result is: ";
     161///     newType->print( std::cerr );
     162///     std::cerr << std::endl;
     163        return sub.pass.subCount;
    165164}
    166165

  • src/SynTree/VarExprReplacer.cc

    rb158d8f rb6838214  
    1616#include <iostream>       // for operator<<, basic_ostream, ostream, basic_o...
    1717
     18#include "Common/PassVisitor.h"
    1819#include "Declaration.h"  // for operator<<, DeclarationWithType
    1920#include "Expression.h"   // for VariableExpr
    2021#include "VarExprReplacer.h"
    2122
    22 VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
     23namespace VarExprReplacer {
     24        namespace {
     25                /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping
     26                struct VarExprReplacer {
     27                private:
     28                        const DeclMap & declMap;
     29                        bool debug;
     30                public:
     31                        VarExprReplacer( const DeclMap & declMap, bool debug = false );
    2332
    24 // replace variable with new node from decl map
    25 void VarExprReplacer::visit( VariableExpr * varExpr ) {
    26         // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
    27         if ( declMap.count( varExpr->get_var() ) ) {
    28                 if ( debug ) {
    29                         std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
     33                        // replace variable with new node from decl map
     34                        void previsit( VariableExpr * varExpr );
     35                };
     36        }
     37
     38        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
     39                PassVisitor<VarExprReplacer> replacer( declMap, debug );
     40                maybeAccept( node, replacer );
     41        }
     42
     43        namespace {
     44                VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
     45
     46                // replace variable with new node from decl map
     47                void VarExprReplacer::previsit( VariableExpr * varExpr ) {
     48                        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
     49                        if ( declMap.count( varExpr->var ) ) {
     50                                if ( debug ) {
     51                                        std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)declMap.at( varExpr->var ) << " " << declMap.at( varExpr->var ) << std::endl;
     52                                }
     53                                varExpr->var = declMap.at( varExpr->var );
     54                        }
    3055                }
    31                 varExpr->set_var( declMap.at( varExpr->get_var() ) );
    3256        }
    33 }
     57} // namespace VarExprReplacer
     58
     59
     60
     61
     62
     63
     64

  • src/SynTree/VarExprReplacer.h

    rb158d8f rb6838214  
    2323class VariableExpr;
    2424
    25 /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping
    26 class VarExprReplacer : public Visitor {
    27 public:
     25namespace VarExprReplacer {
    2826        typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
    29 private:
    30         const DeclMap & declMap;
    31         bool debug;
    32 public:
    33         VarExprReplacer( const DeclMap & declMap, bool debug = false );
    3427
    35         // replace variable with new node from decl map
    36         virtual void visit( VariableExpr * varExpr );
    37 
    38         static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) {
    39                 VarExprReplacer replacer( declMap, debug );
    40                 maybeAccept( node, replacer );
    41         }
    42 };
     28        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
     29}
    4330
    4431// Local Variables: //

  • src/Tuples/TupleAssignment.cc

    rb158d8f rb6838214  
    272272                // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
    273273                if ( right ) args.push_back( new VariableExpr( right ) );
    274                 return new UntypedExpr( new NameExpr( fname ), args );
     274                if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
     275                        args.front() = new AddressExpr( args.front() );
     276                        if ( right ) args.back() = new AddressExpr( args.back() );
     277                        return new UntypedExpr( new NameExpr( "?=?" ), args );
     278                } else {
     279                        return new UntypedExpr( new NameExpr( fname ), args );
     280                }
    275281        }
    276282
    … …  
    291297                if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
    292298                        ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
    293                         ret->set_init( ctorInit );
     299                        ret->init = ctorInit;
    294300                        ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
    295301                        PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs

  • src/Tuples/TupleExpansion.cc

    rb158d8f rb6838214  
    3636namespace Tuples {
    3737        namespace {
    38                 struct MemberTupleExpander final : public Mutator {
    39                         typedef Mutator Parent;
    40                         using Parent::mutate;
    41 
    42                         virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override;
     38                struct MemberTupleExpander final : public WithShortCircuiting, public WithVisitorRef<MemberTupleExpander> {
     39                        void premutate( UntypedMemberExpr * ) { visit_children = false; }
     40                        Expression * postmutate( UntypedMemberExpr * memberExpr );
    4341                };
    4442
    … …  
    7977
    8078        void expandMemberTuples( std::list< Declaration * > & translationUnit ) {
    81                 MemberTupleExpander expander;
     79                PassVisitor<MemberTupleExpander> expander;
    8280                mutateAll( translationUnit, expander );
    8381        }
    … …  
    109107                                // construct a new UntypedMemberExpr with the correct structure , and recursively
    110108                                // expand that member expression.
    111                                 MemberTupleExpander expander;
    112                                 UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() );
    113                                 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), inner );
     109                                PassVisitor<MemberTupleExpander> expander;
     110                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->aggregate, aggr->clone() );
     111                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
    114112                                inner->location = newMemberExpr->location = loc;
    115                                 memberExpr->set_member(nullptr);
    116                                 memberExpr->set_aggregate(nullptr);
     113                                memberExpr->member = nullptr;
     114                                memberExpr->aggregate = nullptr;
    117115                                delete memberExpr;
    118116                                return newMemberExpr->acceptMutator( expander );
    … …  
    126124        }
    127125
    128         Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
    129                 if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->get_member() ) ) {
    130                         Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this );
     126        Expression * MemberTupleExpander::postmutate( UntypedMemberExpr * memberExpr ) {
     127                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->member ) ) {
     128                        Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
    131129                        // aggregate expressions which might be impure must be wrapped in unique expressions
    132130                        // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
    133131                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
    134132                        aggr = new UniqueExpr( aggr );
    135                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
     133                        for ( Expression *& expr : tupleExpr->exprs ) {
    136134                                expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
    137135                                expr->location = memberExpr->location;
    … …  
    143141                        // there may be a tuple expr buried in the aggregate
    144142                        // xxx - this is a memory leak
    145                         UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
     143                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member->clone(), memberExpr->aggregate->acceptMutator( *visitor ) );
    146144                        newMemberExpr->location = memberExpr->location;
    147145                        return newMemberExpr;
    … …  
    202200                        // generate struct type to replace tuple type based on the number of components in the tuple
    203201                        StructDecl * decl = new StructDecl( toString( "_tuple", tupleSize, "_" ) );
     202                        decl->location = tupleType->location;
    204203                        decl->set_body( true );
    205204                        for ( size_t i = 0; i < tupleSize; ++i ) {

  • src/benchmark/Makefile.am

    rb158d8f rb6838214  
    5959        @echo -e '\t"githash": "'${githash}'",'
    6060        @echo -e '\t"arch": "'   ${arch}   '",'
    61         @echo -e '\t"compile": {'
    62         @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
    63         @echo -e '\t\t"dummy" : {}'
    64         @echo -e '\t},'
    6561        @echo -e '\t"ctxswitch": {'
    6662        @echo -en '\t\t"coroutine":'
    … …  
    162158## =========================================================================================================
    163159signal$(EXEEXT) :\
     160        signal-pthread_cond.run \
    164161        signal-upp.run          \
    165162        signal-cfa1.run         \
    … …  
    167164        signal-cfa4.run         \
    168165        signal-java_thread.run
     166
     167signal-pthread_cond$(EXEEXT):
     168        @@BACKEND_CC@ schedint/pthreads.c -DBENCH_N=500000      -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    169169
    170170signal-upp$(EXEEXT):
    … …  
    258258
    259259compile-array$(EXEEXT):
    260         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     260        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    261261
    262262compile-attributes$(EXEEXT):
    263         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     263        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    264264
    265265compile-empty$(EXEEXT):
    266         @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     266        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    267267
    268268compile-expression$(EXEEXT):
    269         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     269        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    270270
    271271compile-io$(EXEEXT):
    272         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     272        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    273273
    274274compile-monitor$(EXEEXT):
    275         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c              @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     275        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/monitor.c           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    276276
    277277compile-operators$(EXEEXT):
    278         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     278        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    279279
    280280compile-thread$(EXEEXT):
    281         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     281        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/thread.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    282282
    283283compile-typeof$(EXEEXT):
    284         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    285 
     284        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c                               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     285

  • src/benchmark/Makefile.in

    rb158d8f rb6838214  
    473473        @echo -e '\t"githash": "'${githash}'",'
    474474        @echo -e '\t"arch": "'   ${arch}   '",'
    475         @echo -e '\t"compile": {'
    476         @+make compile TIME_FORMAT='%e,' PRINT_FORMAT='\t\t\"%s\" :'
    477         @echo -e '\t\t"dummy" : {}'
    478         @echo -e '\t},'
    479475        @echo -e '\t"ctxswitch": {'
    480476        @echo -en '\t\t"coroutine":'
    … …  
    573569
    574570signal$(EXEEXT) :\
     571        signal-pthread_cond.run \
    575572        signal-upp.run          \
    576573        signal-cfa1.run         \
    577574        signal-cfa2.run         \
    578         signal-cfa4.run
     575        signal-cfa4.run         \
     576        signal-java_thread.run
     577
     578signal-pthread_cond$(EXEEXT):
     579        @@BACKEND_CC@ schedint/pthreads.c -DBENCH_N=500000      -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    579580
    580581signal-upp$(EXEEXT):
    … …  
    662663
    663664compile-array$(EXEEXT):
    664         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     665        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    665666
    666667compile-attributes$(EXEEXT):
    667         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     668        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    668669
    669670compile-empty$(EXEEXT):
    670         @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     671        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    671672
    672673compile-expression$(EXEEXT):
    673         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     674        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    674675
    675676compile-io$(EXEEXT):
    676         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     677        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    677678
    678679compile-monitor$(EXEEXT):
    679         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c              @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     680        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/monitor.c           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    680681
    681682compile-operators$(EXEEXT):
    682         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     683        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    683684
    684685compile-thread$(EXEEXT):
    685         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     686        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/thread.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    686687
    687688compile-typeof$(EXEEXT):
    688         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     689        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c                               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    689690
    690691# Tell versions [3.59,3.63) of GNU make to not export all variables.

  • src/libcfa/bits/defs.h

    rb158d8f rb6838214  
    1 //
     1// 
    22// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
    33//
    44// The contents of this file are covered under the licence agreement in the
    55// file "LICENCE" distributed with Cforall.
    6 //
    7 // bits/defs.h --
    8 //
     6// 
     7// defs.h --
     8// 
    99// Author           : Thierry Delisle
    10 // Created On       : Thu Nov 09 13:24:10 2017
    11 // Last Modified By :
    12 // Last Modified On :
    13 // Update Count     :
    14 //
     10// Created On       : Thu Nov  9 13:24:10 2017
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Jan  2 09:17:06 2018
     13// Update Count     : 2
     14// 
    1515
    1616#pragma once
    … …  
    2020#include <stdint.h>
    2121
    22 #define unlikely(x)    __builtin_expect(!!(x), 0)
    23 #define likely  (x)    __builtin_expect(!!(x), 1)
     22#define likely(x)   __builtin_expect(!!(x), 1)
     23#define unlikely(x) __builtin_expect(!!(x), 0)
    2424#define thread_local _Thread_local
    2525

  • src/libcfa/concurrency/monitor.c

    rb158d8f rb6838214  
    534534        __lock_size_t actual_count = aggregate( mon_storage, mask );
    535535
    536         __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
     536        __cfaabi_dbg_print_buffer_decl( "Kernel : waitfor %"PRIdFAST16" (s: %"PRIdFAST16", m: %"PRIdFAST16")\n", actual_count, mask.size, (__lock_size_t)max);
    537537
    538538        if(actual_count == 0) return;
    … …  
    575575                                monitor_save;
    576576
    577                                 __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %d monitors : ", count );
     577                                __cfaabi_dbg_print_buffer_local( "Kernel :  baton of %"PRIdFAST16" monitors : ", count );
    578578                                #ifdef __CFA_DEBUG_PRINT__
    579579                                        for( int i = 0; i < count; i++) {

  • src/libcfa/concurrency/preemption.c

    rb158d8f rb6838214  
    303303        // Check if it is safe to preempt here
    304304        if( !preemption_ready() ) { return; }
     305
     306        // __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
    305307
    306308        preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler

  • src/libcfa/fstream

    rb158d8f rb6838214  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  7 08:06:11 2017
    13 // Update Count     : 129
     12// Last Modified On : Thu Dec  7 15:17:26 2017
     13// Update Count     : 130
    1414//
    1515
    … …  
    5252int flush( ofstream & );
    5353void open( ofstream &, const char * name, const char * mode );
     54void open( ofstream &, const char * name );
    5455void close( ofstream & );
    5556ofstream & write( ofstream &, const char * data, unsigned long int size );
    … …  
    5859void ?{}( ofstream & os );
    5960void ?{}( ofstream & os, const char * name, const char * mode );
     61void ?{}( ofstream & os, const char * name );
    6062
    6163extern ofstream & sout, & serr;
    … …  
    6971int fail( ifstream & is );
    7072int eof( ifstream & is );
     73void open( ifstream & is, const char * name, const char * mode );
    7174void open( ifstream & is, const char * name );
    7275void close( ifstream & is );
    … …  
    7679
    7780void ?{}( ifstream & is );
     81void ?{}( ifstream & is, const char * name, const char * mode );
    7882void ?{}( ifstream & is, const char * name );
    7983

  • src/libcfa/fstream.c

    rb158d8f rb6838214  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  7 08:35:01 2017
    13 // Update Count     : 270
     12// Last Modified On : Sat Dec  9 09:31:23 2017
     13// Update Count     : 275
    1414//
    1515
    … …  
    4646
    4747// public
    48 void ?{}( ofstream & os ) {}
     48void ?{}( ofstream & os ) { os.file = 0; }
    4949
    5050void ?{}( ofstream & os, const char * name, const char * mode ) {
    5151        open( os, name, mode );
     52}
     53void ?{}( ofstream & os, const char * name ) {
     54        open( os, name, "w" );
    5255}
    5356
    … …  
    8487
    8588int fail( ofstream & os ) {
    86         return ferror( (FILE *)(os.file) );
     89        return os.file == 0 || ferror( (FILE *)(os.file) );
    8790} // fail
    8891
    … …  
    9396void open( ofstream & os, const char * name, const char * mode ) {
    9497        FILE *file = fopen( name, mode );
    95         if ( file == 0 ) {                                                                      // do not change unless successful
    96                 fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
    97                 perror( 0 );
    98                 exit( EXIT_FAILURE );
    99         } // if
     98        // if ( file == 0 ) {                                                                   // do not change unless successful
     99        //      fprintf( stderr, IO_MSG "open output file \"%s\", ", name );
     100        //      perror( 0 );
     101        //      exit( EXIT_FAILURE );
     102        // } // if
    100103        (os){ file, true, false, " ", ", " };
     104} // open
     105
     106void open( ofstream & os, const char * name ) {
     107        open( os, name, "w" );
    101108} // open
    102109
    … …  
    152159
    153160// public
    154 void ?{}( ifstream & is ) {}
    155 
     161void ?{}( ifstream & is ) {     is.file = 0; }
     162
     163void ?{}( ifstream & is, const char * name, const char * mode ) {
     164        open( is, name, mode );
     165}
    156166void ?{}( ifstream & is, const char * name ) {
    157         open( is, name );
     167        open( is, name, "r" );
    158168}
    159169
    160170int fail( ifstream & is ) {
    161         return ferror( (FILE *)(is.file) );
     171        return is.file == 0 || ferror( (FILE *)(is.file) );
    162172} // fail
    163173
    … …  
    166176} // eof
    167177
     178void open( ifstream & is, const char * name, const char * mode ) {
     179        FILE *file = fopen( name, mode );
     180        // if ( file == 0 ) {                                                                   // do not change unless successful
     181        //      fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
     182        //      perror( 0 );
     183        //      exit( EXIT_FAILURE );
     184        // } // if
     185        is.file = file;
     186} // open
     187
    168188void open( ifstream & is, const char * name ) {
    169         FILE *file = fopen( name, "r" );
    170         if ( file == 0 ) {                                                                      // do not change unless successful
    171                 fprintf( stderr, IO_MSG "open input file \"%s\", ", name );
    172                 perror( 0 );
    173                 exit( EXIT_FAILURE );
    174         } // if
    175         is.file = file;
     189        open( is, name, "r" );
    176190} // open
    177191

  • src/libcfa/iostream

    rb158d8f rb6838214  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec  6 23:03:30 2017
    13 // Update Count     : 144
     12// Last Modified On : Thu Dec 21 13:55:41 2017
     13// Update Count     : 145
    1414//
    1515
    … …  
    5555
    5656// implement writable for intrinsic types
     57
     58forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, _Bool );
    5759
    5860forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype &, char );

  • src/libcfa/iostream.c

    rb158d8f rb6838214  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Dec  6 23:03:43 2017
    13 // Update Count     : 426
     12// Last Modified On : Thu Dec 21 13:55:09 2017
     13// Update Count     : 427
    1414//
    1515
    … …  
    2323#include <complex.h>                                                                    // creal, cimag
    2424}
     25
     26forall( dtype ostype | ostream( ostype ) )
     27ostype & ?|?( ostype & os, _Bool b ) {
     28        if ( sepPrt( os ) ) fmt( os, "%s", sepGetCur( os ) );
     29        fmt( os, "%s", b ? "true" : "false" );
     30        return os;
     31} // ?|?
    2532
    2633forall( dtype ostype | ostream( ostype ) )

  • src/libcfa/stdlib

    rb158d8f rb6838214  
    1010// Created On       : Thu Jan 28 17:12:35 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Oct 31 13:47:24 2017
    13 // Update Count     : 245
     12// Last Modified On : Tue Jan  2 12:21:04 2018
     13// Update Count     : 292
    1414//
    1515
    1616#pragma once
     17
     18//#define _XOPEN_SOURCE 600                                                             // posix_memalign, *rand48
     19#include <stdlib.h>                                                                             // strto*, *abs
    1720
    1821//---------------------------------------
    … …  
    7780        //printf( "X8\n" );
    7881        T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
    79     return (T *)memset( ptr, (int)fill, sizeof(T) );                    // initial with fill value
     82    return (T *)memset( ptr, (int)fill, sizeof(T) );    // initial with fill value
    8083} // alloc
    8184
    … …  
    150153//---------------------------------------
    151154
    152 int ato( const char * ptr );
    153 unsigned int ato( const char * ptr );
    154 long int ato( const char * ptr );
    155 unsigned long int ato( const char * ptr );
    156 long long int ato( const char * ptr );
    157 unsigned long long int ato( const char * ptr );
    158 float ato( const char * ptr );
    159 double ato( const char * ptr );
    160 long double ato( const char * ptr );
    161 float _Complex ato( const char * ptr );
    162 double _Complex ato( const char * ptr );
    163 long double _Complex ato( const char * ptr );
    164 
    165 int strto( const char * sptr, char ** eptr, int base );
    166 unsigned int strto( const char * sptr, char ** eptr, int base );
    167 long int strto( const char * sptr, char ** eptr, int base );
    168 unsigned long int strto( const char * sptr, char ** eptr, int base );
    169 long long int strto( const char * sptr, char ** eptr, int base );
    170 unsigned long long int strto( const char * sptr, char ** eptr, int base );
    171 float strto( const char * sptr, char ** eptr );
    172 double strto( const char * sptr, char ** eptr );
    173 long double strto( const char * sptr, char ** eptr );
     155static inline int strto( const char * sptr, char ** eptr, int base ) { return (int)strtol( sptr, eptr, base ); }
     156static inline unsigned int strto( const char * sptr, char ** eptr, int base ) { return (unsigned int)strtoul( sptr, eptr, base ); }
     157static inline long int strto( const char * sptr, char ** eptr, int base ) { return strtol( sptr, eptr, base ); }
     158static inline unsigned long int strto( const char * sptr, char ** eptr, int base ) { return strtoul( sptr, eptr, base ); }
     159static inline long long int strto( const char * sptr, char ** eptr, int base ) { return strtoll( sptr, eptr, base ); }
     160static inline unsigned long long int strto( const char * sptr, char ** eptr, int base ) { return strtoull( sptr, eptr, base ); }
     161
     162static inline float strto( const char * sptr, char ** eptr ) { return strtof( sptr, eptr ); }
     163static inline double strto( const char * sptr, char ** eptr ) { return strtod( sptr, eptr ); }
     164static inline long double strto( const char * sptr, char ** eptr ) { return strtold( sptr, eptr ); }
     165
    174166float _Complex strto( const char * sptr, char ** eptr );
    175167double _Complex strto( const char * sptr, char ** eptr );
    176168long double _Complex strto( const char * sptr, char ** eptr );
    177169
    178 //---------------------------------------
    179 
    180 forall( otype T | { int ?<?( T, T ); } )
    181 T * bsearch( T key, const T * arr, size_t dim );
    182 
    183 forall( otype T | { int ?<?( T, T ); } )
    184 unsigned int bsearch( T key, const T * arr, size_t dim );
    185 
    186 
    187 forall( otype T | { int ?<?( T, T ); } )
    188 void qsort( const T * arr, size_t dim );
     170static inline int ato( const char * sptr ) {return (int)strtol( sptr, 0, 10 ); }
     171static inline unsigned int ato( const char * sptr ) { return (unsigned int)strtoul( sptr, 0, 10 ); }
     172static inline long int ato( const char * sptr ) { return strtol( sptr, 0, 10 ); }
     173static inline unsigned long int ato( const char * sptr ) { return strtoul( sptr, 0, 10 ); }
     174static inline long long int ato( const char * sptr ) { return strtoll( sptr, 0, 10 ); }
     175static inline unsigned long long int ato( const char * sptr ) { return strtoull( sptr, 0, 10 ); }
     176
     177static inline float ato( const char * sptr ) { return strtof( sptr, 0 ); }
     178static inline double ato( const char * sptr ) { return strtod( sptr, 0 ); }
     179static inline long double ato( const char * sptr ) { return strtold( sptr, 0 ); }
     180
     181static inline float _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     182static inline double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     183static inline long double _Complex ato( const char * sptr ) { return strto( sptr, NULL ); }
     184
     185//---------------------------------------
     186
     187forall( otype E | { int ?<?( E, E ); } )
     188E * bsearch( E key, const E * vals, size_t dim );
     189
     190forall( otype E | { int ?<?( E, E ); } )
     191size_t bsearch( E key, const E * vals, size_t dim );
     192
     193forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     194E * bsearch( K key, const E * vals, size_t dim );
     195
     196forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     197size_t bsearch( K key, const E * vals, size_t dim );
     198
     199
     200forall( otype E | { int ?<?( E, E ); } )
     201E * bsearchl( E key, const E * vals, size_t dim );
     202
     203forall( otype E | { int ?<?( E, E ); } )
     204size_t bsearchl( E key, const E * vals, size_t dim );
     205
     206forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     207E * bsearchl( K key, const E * vals, size_t dim );
     208
     209forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     210size_t bsearchl( K key, const E * vals, size_t dim );
     211
     212
     213forall( otype E | { int ?<?( E, E ); } )
     214E * bsearchu( E key, const E * vals, size_t dim );
     215
     216forall( otype E | { int ?<?( E, E ); } )
     217size_t bsearchu( E key, const E * vals, size_t dim );
     218
     219forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     220E * bsearchu( K key, const E * vals, size_t dim );
     221
     222forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     223size_t bsearchu( K key, const E * vals, size_t dim );
     224
     225
     226forall( otype E | { int ?<?( E, E ); } )
     227void qsort( E * vals, size_t dim );
    189228
    190229//---------------------------------------
    … …  
    198237//---------------------------------------
    199238
    200 unsigned char abs( signed char );
     239static inline unsigned char abs( signed char v ) { return abs( (int)v ); }
    201240extern "C" { int abs( int ); }                                                  // use default C routine for int
    202 unsigned long int abs( long int );
    203 unsigned long long int abs( long long int );
    204 float abs( float );
    205 double abs( double );
    206 long double abs( long double );
    207 float abs( float _Complex );
    208 double abs( double _Complex );
    209 long double abs( long double _Complex );
     241static inline unsigned long int abs( long int v ) { return labs( v ); }
     242static inline unsigned long long int abs( long long int v ) { return llabs( v ); }
     243
     244extern "C" {
     245double fabs( double );
     246float fabsf( float );
     247long double fabsl( long double );
     248} // extern "C"
     249static inline float abs( float x ) { return fabsf( x ); }
     250static inline double abs( double x ) { return fabs( x ); }
     251static inline long double abs( long double x ) { return fabsl( x ); }
     252
     253extern "C" {
     254double cabs( double _Complex );
     255float cabsf( float _Complex );
     256long double cabsl( long double _Complex );
     257} // extern "C"
     258static inline float abs( float _Complex x ) { return cabsf( x ); }
     259static inline double abs( double _Complex x ) { return cabs( x ); }
     260static inline long double abs( long double _Complex x ) { return cabsl( x ); }
     261
    210262forall( otype T | { void ?{}( T &, zero_t ); int ?<?( T, T ); T -?( T ); } )
    211263T abs( T );
    … …  
    213265//---------------------------------------
    214266
    215 void random_seed( long int s );
     267extern "C" { void srandom( unsigned int seed ); }               // override C version
    216268char random( void );
     269char random( char u );
    217270char random( char l, char u );
    218271int random( void );
     272int random( int u );
     273int random( int l, int u );
    219274unsigned int random( void );
    220275unsigned int random( unsigned int u );
    221276unsigned int random( unsigned int l, unsigned int u );
    222 //long int random( void );
     277extern "C" { long int random( void ); }                                 // override C version
     278long int random( long int u );
     279long int random( long int l, long int u );
    223280unsigned long int random( void );
    224281unsigned long int random( unsigned long int u );
    … …  
    233290
    234291forall( otype T | { int ?<?( T, T ); } )
    235 T min( T t1, T t2 );
     292static inline T min( T t1, T t2 ) { return t1 < t2 ? t1 : t2; }
    236293
    237294forall( otype T | { int ?>?( T, T ); } )
    238 T max( T t1, T t2 );
     295static inline T max( T t1, T t2 ) { return t1 > t2 ? t1 : t2; }
    239296
    240297forall( otype T | { T min( T, T ); T max( T, T ); } )
    241 T clamp( T value, T min_val, T max_val );
     298static inline T clamp( T value, T min_val, T max_val ) { return max( min_val, min( value, max_val ) ); }
    242299
    243300forall( otype T )
    244 void swap( T & t1, T & t2 );
     301static inline void swap( T & v1, T & v2 ) { T temp = v1; v1 = v2; v2 = temp; }
    245302
    246303// Local Variables: //

  • src/libcfa/stdlib.c

    rb158d8f rb6838214  
    1010// Created On       : Thu Jan 28 17:10:29 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Oct 30 22:43:02 2017
    13 // Update Count     : 297
     12// Last Modified On : Tue Jan  2 12:20:32 2018
     13// Update Count     : 441
    1414//
    1515
    … …  
    1919
    2020#define _XOPEN_SOURCE 600                                                               // posix_memalign, *rand48
    21 #include <stdlib.h>                                                                             // malloc, free, calloc, realloc, memalign, posix_memalign, bsearch
    2221#include <string.h>                                                                             // memcpy, memset
    2322#include <malloc.h>                                                                             // malloc_usable_size
    2423#include <math.h>                                                                               // fabsf, fabs, fabsl
    2524#include <complex.h>                                                                    // _Complex_I
     25#include <assert.h>
    2626
    2727// resize, non-array types
    … …  
    9393//---------------------------------------
    9494
    95 int ato( const char * ptr ) {
    96         int i;
    97         if ( sscanf( ptr, "%d", &i ) == EOF ) {}
    98         return i;
    99 } // ato
    100 
    101 unsigned int ato( const char * ptr ) {
    102         unsigned int ui;
    103         if ( sscanf( ptr, "%u", &ui ) == EOF ) {}
    104         return ui;
    105 } // ato
    106 
    107 long int ato( const char * ptr ) {
    108         long int li;
    109         if ( sscanf( ptr, "%ld", &li ) == EOF ) {}
    110         return li;
    111 } // ato
    112 
    113 unsigned long int ato( const char * ptr ) {
    114         unsigned long int uli;
    115         if ( sscanf( ptr, "%lu", &uli ) == EOF ) {}
    116         return uli;
    117 } // ato
    118 
    119 long long int ato( const char * ptr ) {
    120         long long int lli;
    121         if ( sscanf( ptr, "%lld", &lli ) == EOF ) {}
    122         return lli;
    123 } // ato
    124 
    125 unsigned long long int ato( const char * ptr ) {
    126         unsigned long long int ulli;
    127         if ( sscanf( ptr, "%llu", &ulli ) == EOF ) {}
    128         return ulli;
    129 } // ato
    130 
    131 
    132 float ato( const char * ptr ) {
    133         float f;
    134         if ( sscanf( ptr, "%f", &f ) == EOF ) {}
    135         return f;
    136 } // ato
    137 
    138 double ato( const char * ptr ) {
    139         double d;
    140         if ( sscanf( ptr, "%lf", &d ) == EOF ) {}
    141         return d;
    142 } // ato
    143 
    144 long double ato( const char * ptr ) {
    145         long double ld;
    146         if ( sscanf( ptr, "%Lf", &ld ) == EOF ) {}
    147         return ld;
    148 } // ato
    149 
    150 
    151 float _Complex ato( const char * ptr ) {
    152         float re, im;
    153         if ( sscanf( ptr, "%g%gi", &re, &im ) == EOF ) {}
    154         return re + im * _Complex_I;
    155 } // ato
    156 
    157 double _Complex ato( const char * ptr ) {
    158         double re, im;
    159         if ( sscanf( ptr, "%lf%lfi", &re, &im ) == EOF ) {}
    160         return re + im * _Complex_I;
    161 } // ato
    162 
    163 long double _Complex ato( const char * ptr ) {
    164         long double re, im;
    165         if ( sscanf( ptr, "%Lf%Lfi", &re, &im ) == EOF ) {}
    166         return re + im * _Complex_I;
    167 } // ato
    168 
    169 
    170 int strto( const char * sptr, char ** eptr, int base ) {
    171         return (int)strtol( sptr, eptr, base );
    172 } // strto
    173 
    174 unsigned int strto( const char * sptr, char ** eptr, int base ) {
    175         return (unsigned int)strtoul( sptr, eptr, base );
    176 } // strto
    177 
    178 long int strto( const char * sptr, char ** eptr, int base ) {
    179         return strtol( sptr, eptr, base );
    180 } // strto
    181 
    182 unsigned long int strto( const char * sptr, char ** eptr, int base ) {
    183         return strtoul( sptr, eptr, base );
    184 } // strto
    185 
    186 long long int strto( const char * sptr, char ** eptr, int base ) {
    187         return strtoll( sptr, eptr, base );
    188 } // strto
    189 
    190 unsigned long long int strto( const char * sptr, char ** eptr, int base ) {
    191         return strtoull( sptr, eptr, base );
    192 } // strto
    193 
    194 
    195 float strto( const char * sptr, char ** eptr ) {
    196         return strtof( sptr, eptr );
    197 } // strto
    198 
    199 double strto( const char * sptr, char ** eptr ) {
    200         return strtod( sptr, eptr );
    201 } // strto
    202 
    203 long double strto( const char * sptr, char ** eptr ) {
    204         return strtold( sptr, eptr );
    205 } // strto
    206 
    207 
    20895float _Complex strto( const char * sptr, char ** eptr ) {
    20996        float re, im;
    210         re = strtof( sptr, eptr );
    211         if ( sptr == *eptr ) return 0.0;
    212         im = strtof( sptr, eptr );
    213         if ( sptr == *eptr ) return 0.0;
     97        char * eeptr;
     98        re = strtof( sptr, &eeptr );
     99        if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     100        im = strtof( eeptr, &eeptr );
     101        if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
     102        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0f + 0.0f * _Complex_I; }
    214103        return re + im * _Complex_I;
    215104} // strto
    … …  
    217106double _Complex strto( const char * sptr, char ** eptr ) {
    218107        double re, im;
    219         re = strtod( sptr, eptr );
    220         if ( sptr == *eptr ) return 0.0;
    221         im = strtod( sptr, eptr );
    222         if ( sptr == *eptr ) return 0.0;
     108        char * eeptr;
     109        re = strtod( sptr, &eeptr );
     110        if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     111        im = strtod( eeptr, &eeptr );
     112        if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
     113        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0 + 0.0 * _Complex_I; }
    223114        return re + im * _Complex_I;
    224115} // strto
    … …  
    226117long double _Complex strto( const char * sptr, char ** eptr ) {
    227118        long double re, im;
    228         re = strtold( sptr, eptr );
    229         if ( sptr == *eptr ) return 0.0;
    230         im = strtold( sptr, eptr );
    231         if ( sptr == *eptr ) return 0.0;
     119        char * eeptr;
     120        re = strtold( sptr, &eeptr );
     121        if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     122        im = strtold( eeptr, &eeptr );
     123        if ( sptr == *eeptr ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
     124        if ( *eeptr != 'i' ) { if ( eptr != 0 ) *eptr = eeptr; return 0.0L + 0.0L * _Complex_I; }
    232125        return re + im * _Complex_I;
    233126} // strto
    … …  
    235128//---------------------------------------
    236129
    237 forall( otype T | { int ?<?( T, T ); } )
    238 T * bsearch( T key, const T * arr, size_t dim ) {
    239         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    240         return (T *)bsearch( &key, arr, dim, sizeof(T), comp );
    241 } // bsearch
    242 
    243 forall( otype T | { int ?<?( T, T ); } )
    244 unsigned int bsearch( T key, const T * arr, size_t dim ) {
    245         T *result = bsearch( key, arr, dim );
    246         return result ? result - arr : dim;                                     // pointer subtraction includes sizeof(T)
    247 } // bsearch
    248 
    249 forall( otype T | { int ?<?( T, T ); } )
    250 void qsort( const T * arr, size_t dim ) {
    251         int comp( const void * t1, const void * t2 ) { return *(T *)t1 < *(T *)t2 ? -1 : *(T *)t2 < *(T *)t1 ? 1 : 0; }
    252         qsort( arr, dim, sizeof(T), comp );
     130forall( otype E | { int ?<?( E, E ); } )
     131E * bsearch( E key, const E * vals, size_t dim ) {
     132        int cmp( const void * t1, const void * t2 ) {
     133                return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
     134        } // cmp
     135        return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
     136} // bsearch
     137
     138forall( otype E | { int ?<?( E, E ); } )
     139size_t bsearch( E key, const E * vals, size_t dim ) {
     140        E * result = bsearch( key, vals, dim );
     141        return result ? result - vals : dim;                            // pointer subtraction includes sizeof(E)
     142} // bsearch
     143
     144forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     145E * bsearch( K key, const E * vals, size_t dim ) {
     146        int cmp( const void * t1, const void * t2 ) {
     147                return *(K *)t1 < getKey( *(E *)t2 ) ? -1 : getKey( *(E *)t2 ) < *(K *)t1 ? 1 : 0;
     148        } // cmp
     149        return (E *)bsearch( &key, vals, dim, sizeof(E), cmp );
     150} // bsearch
     151
     152forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     153size_t bsearch( K key, const E * vals, size_t dim ) {
     154        E * result = bsearch( key, vals, dim );
     155        return result ? result - vals : dim;                            // pointer subtraction includes sizeof(E)
     156} // bsearch
     157
     158
     159forall( otype E | { int ?<?( E, E ); } )
     160size_t bsearchl( E key, const E * vals, size_t dim ) {
     161        size_t l = 0, m, h = dim;
     162        while ( l < h ) {
     163                m = (l + h) / 2;
     164                if ( (E &)(vals[m]) < key ) {                                   // cast away const
     165                        l = m + 1;
     166                } else {
     167                        h = m;
     168                } // if
     169        } // while
     170        return l;
     171} // bsearchl
     172
     173forall( otype E | { int ?<?( E, E ); } )
     174E * bsearchl( E key, const E * vals, size_t dim ) {
     175        size_t posn = bsearchl( key, vals, dim );
     176        return (E *)(&vals[posn]);                                                      // cast away const
     177} // bsearchl
     178
     179forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     180size_t bsearchl( K key, const E * vals, size_t dim ) {
     181        size_t l = 0, m, h = dim;
     182        while ( l < h ) {
     183                m = (l + h) / 2;
     184                if ( getKey( vals[m] ) < key ) {
     185                        l = m + 1;
     186                } else {
     187                        h = m;
     188                } // if
     189        } // while
     190        return l;
     191} // bsearchl
     192
     193forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     194E * bsearchl( K key, const E * vals, size_t dim ) {
     195        size_t posn = bsearchl( key, vals, dim );
     196        return (E *)(&vals[posn]);                                                      // cast away const
     197} // bsearchl
     198
     199
     200forall( otype E | { int ?<?( E, E ); } )
     201size_t bsearchu( E key, const E * vals, size_t dim ) {
     202        size_t l = 0, m, h = dim;
     203        while ( l < h ) {
     204                m = (l + h) / 2;
     205                if ( ! ( key < (E &)(vals[m]) ) ) {                             // cast away const
     206                        l = m + 1;
     207                } else {
     208                        h = m;
     209                } // if
     210        } // while
     211        return l;
     212} // bsearchu
     213
     214forall( otype E | { int ?<?( E, E ); } )
     215E * bsearchu( E key, const E * vals, size_t dim ) {
     216        size_t posn = bsearchu( key, vals, dim );
     217        return (E *)(&vals[posn]);
     218} // bsearchu
     219
     220forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     221size_t bsearchu( K key, const E * vals, size_t dim ) {
     222        size_t l = 0, m, h = dim;
     223        while ( l < h ) {
     224                m = (l + h) / 2;
     225                if ( ! ( key < getKey( vals[m] ) ) ) {
     226                        l = m + 1;
     227                } else {
     228                        h = m;
     229                } // if
     230        } // while
     231        return l;
     232} // bsearchu
     233
     234forall( otype K, otype E | { int ?<?( K, K ); K getKey( const E & ); } )
     235E * bsearchu( K key, const E * vals, size_t dim ) {
     236        size_t posn = bsearchu( key, vals, dim );
     237        return (E *)(&vals[posn]);
     238} // bsearchu
     239
     240
     241forall( otype E | { int ?<?( E, E ); } )
     242void qsort( E * vals, size_t dim ) {
     243        int cmp( const void * t1, const void * t2 ) {
     244                return *(E *)t1 < *(E *)t2 ? -1 : *(E *)t2 < *(E *)t1 ? 1 : 0;
     245        } // cmp
     246        qsort( vals, dim, sizeof(E), cmp );
    253247} // qsort
    254248
    … …  
    263257//---------------------------------------
    264258
    265 unsigned char abs( signed char v ) { return abs( (int)v ); }
    266 unsigned long int abs( long int v ) { return labs( v ); }
    267 unsigned long long int abs( long long int v ) { return llabs( v ); }
    268 float abs( float x ) { return fabsf( x ); }
    269 double abs( double x ) { return fabs( x ); }
    270 long double abs( long double x ) { return fabsl( x ); }
    271 float abs( float _Complex x ) { return cabsf( x ); }
    272 double abs( double _Complex x ) { return cabs( x ); }
    273 long double abs( long double _Complex x ) { return cabsl( x ); }
    274 
    275 //---------------------------------------
    276 
    277 void random_seed( long int s ) { srand48( s ); }
    278 char random( void ) { return mrand48(); }
    279 char random( char l, char u ) { return lrand48() % (u - l) + l; }
    280 int random( void ) { return mrand48(); }
    281 unsigned int random( void ) { return lrand48(); }
    282 unsigned int random( unsigned int u ) { return lrand48() % u; }
    283 unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; }
    284 //long int random( void ) { return mrand48(); }
     259extern "C" { void srandom( unsigned int seed ) { srand48( seed ); } } // override C version
     260char random( void ) { return (unsigned long int)random(); }
     261char random( char u ) { return random( (unsigned long int)u ); }
     262char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
     263int random( void ) { return (long int)random(); }
     264int random( int u ) { return random( (long int)u ); }
     265int random( int l, int u ) { return random( (long int)l, (long int)u ); }
     266unsigned int random( void ) { return (unsigned long int)random(); }
     267unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); }
     268unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
     269extern "C" { long int random( void ) { return mrand48(); } } // override C version
     270long int random( long int u ) { if ( u < 0 ) return random( u, 0 ); else return random( 0, u ); }
     271long int random( long int l, long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
    285272unsigned long int random( void ) { return lrand48(); }
    286273unsigned long int random( unsigned long int u ) { return lrand48() % u; }
    287 unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }
    288 float random( void ) { return (float)drand48(); }               // otherwise float uses lrand48
     274unsigned long int random( unsigned long int l, unsigned long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
     275float random( void ) { return (float)drand48(); }               // cast otherwise float uses lrand48
    289276double random( void ) { return drand48(); }
    290277float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
    291278double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
    292 long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
    293 
    294 //---------------------------------------
    295 
    296 forall( otype T | { int ?<?( T, T ); } )
    297 T min( T t1, T t2 ) {
    298         return t1 < t2 ? t1 : t2;
    299 } // min
    300 
    301 forall( otype T | { int ?>?( T, T ); } )
    302 T max( T t1, T t2 ) {
    303         return t1 > t2 ? t1 : t2;
    304 } // max
    305 
    306 forall( otype T | { T min( T, T ); T max( T, T ); } )
    307 T clamp( T value, T min_val, T max_val ) {
    308         return max( min_val, min( value, max_val ) );
    309 } // clamp
    310 
    311 forall( otype T )
    312 void swap( T & t1, T & t2 ) {
    313         T temp = t1;
    314         t1 = t2;
    315         t2 = temp;
    316 } // swap
     279long double _Complex random( void ) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
     280
    317281
    318282// Local Variables: //

  • src/tests/.expect/alloc-ERROR.txt

    rb158d8f rb6838214  
    1 alloc.c:259:1 error: No reasonable alternatives for expression Applying untyped:
     1alloc.c:264:1 error: No reasonable alternatives for expression Applying untyped:
     2  Name: ?=?
     3...to:
     4  Name: p
     5  Applying untyped:
     6    Name: realloc
     7  ...to:
     8    Name: stp
     9    Applying untyped:
     10      Name: ?*?
     11    ...to:
     12      Name: dim
     13      Sizeof Expression on: Applying untyped:
     14          Name: *?
     15        ...to:
     16          Name: stp
     17
     18
     19
     20
     21alloc.c:265:1 error: No reasonable alternatives for expression Applying untyped:
    222  Name: ?=?
    323...to:
    … …  
    1939
    2040
    21 alloc.c:260:1 error: No reasonable alternatives for expression Applying untyped:
     41alloc.c:266:1 error: No reasonable alternatives for expression Applying untyped:
    2242  Name: ?=?
    2343...to:
    … …  
    3050
    3151
    32 alloc.c:261:1 error: No reasonable alternatives for expression Applying untyped:
     52alloc.c:267:1 error: No reasonable alternatives for expression Applying untyped:
    3353  Name: ?=?
    3454...to:

  • src/tests/.expect/alloc.txt

    rb158d8f rb6838214  
    6060pointer arithmetic 0
    6161CFA deep malloc 0xdeadbeef
    62 
    63 SHOULD FAIL

  • src/tests/.expect/ato.txt

    rb158d8f rb6838214  
    1212123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i
    1313123.45678901234-123.456789i 123.45678901234-123.4567890i
     14-123 -123
     15123 123
     16-123 -123
     17123 123
     18-123 -123
     19123 123
     20-123.456 -123.456
     21-123.456789012346 -123.4567890123456
     22-123.456789012345679 -123.45678901234567890123456789
     23-123.456-123.456i -123.456-123.456i
     240+0i 2  3
     25-123.456789012346+123.456789012346i -123.4567890123456+123.4567890123456i
     26123.456789012345679-123.456789012345679i 123.45678901234567890123456789-123.45678901234567890123456789i
     27123.45678901234-123.456789i 123.45678901234-123.4567890i

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

    rb158d8f rb6838214  
    694694    return ___retval_main__i_1;
    695695}
    696 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
     696static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    697697static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    698698signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

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

    rb158d8f rb6838214  
    694694    return ___retval_main__i_1;
    695695}
    696 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
     696static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    697697static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    698698signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

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

    rb158d8f rb6838214  
    167167    return ___retval_main__i_1;
    168168}
    169 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
     169static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    170170static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    171171signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

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

    rb158d8f rb6838214  
    167167    return ___retval_main__i_1;
    168168}
    169 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
     169static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1((signed int )argc, (const char **)argv); }
    170170static inline signed int invoke_main(signed int argc, char **argv, char **envp);
    171171signed int main(signed int __argc__i_1, char **__argv__PPc_1, char **__envp__PPc_1){

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

    rb158d8f rb6838214  
    11void __for_each__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
    22void __for_each_reverse__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
    3 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object103), __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_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, char __anonymous_object109);
    4 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object131), __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_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, signed char __anonymous_object137);
    5 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object159), __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_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, unsigned char __anonymous_object165);
    6 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object187), __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_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, signed short int __anonymous_object193);
    7 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object215), __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_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, unsigned short int __anonymous_object221);
    8 void *___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_Rd0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object243), __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_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, signed int __anonymous_object249);
    9 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object271), __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_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, unsigned int __anonymous_object277);
    10 void *___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_Rd0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object299), __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_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, signed long int __anonymous_object305);
    11 void *___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_Rd0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object327), __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_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long long int __anonymous_object333);
    12 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object355), __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_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, unsigned long int __anonymous_object361);
    13 void *___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_Rd0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object383), __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_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long long int __anonymous_object389);
    14 void *___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_Rd0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object411), __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_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, float __anonymous_object417);
    15 void *___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_Rd0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object439), __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_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, double __anonymous_object445);
    16 void *___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_Rd0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object467), __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_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, long double __anonymous_object473);
    17 void *___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_Rd0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object495), __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_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, float _Complex __anonymous_object501);
    18 void *___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_Rd0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object523), __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_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, double _Complex __anonymous_object529);
    19 void *___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_Rd0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object551), __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_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, long double _Complex __anonymous_object557);
    20 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object579), __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_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, const char *__anonymous_object585);
    21 void *___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_Rd0PCUs__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object607), __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_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const unsigned short int *__anonymous_object613);
    22 void *___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_Rd0PCUi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object635), __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_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const unsigned int *__anonymous_object641);
    23 void *___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_Rd0PCi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object663), __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_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, const signed int *__anonymous_object669);
    24 void *___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_Rd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object670), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object672, _Bool __anonymous_object673), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object675, const char *__anonymous_object676), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object677), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object678, _Bool __anonymous_object679), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object680), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object685, const char *__anonymous_object686), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object687), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object688, const char *__anonymous_object689), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object691), __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_object692, const char *__anonymous_object693, unsigned long int __anonymous_object694), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object695, const char *__fmt__PCc_1, ...), void *__anonymous_object696, const void *__anonymous_object697);
    25 void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_bitor__PFRd0_Rd0tVARGS2__FRd0_Rd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object698)(), void *__anonymous_object699, void *__anonymous_object700), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object701)(), void *__anonymous_object702, void *__anonymous_object703), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object704)(), void *__anonymous_object705, void *__anonymous_object706), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object707)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object708, void *__anonymous_object709), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object710, void *__anonymous_object711), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object713, void *__anonymous_object714), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object715), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype2tT__1)(void *__anonymous_object716, void *__anonymous_object717), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object720, _Bool __anonymous_object721), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object722), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object723, const char *__anonymous_object724), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object726, _Bool __anonymous_object727), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object728), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object733, const char *__anonymous_object734), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object736, const char *__anonymous_object737), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object739), __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_object740, const char *__anonymous_object741, unsigned long int __anonymous_object742), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object743, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype7tParams__1)(void *__anonymous_object744, void *__anonymous_object745), void *__os__R7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
    26 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object767), __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_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772, void *(*__anonymous_object773)(void *__anonymous_object774));
    27 void *__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object775), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object776), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object777, _Bool __anonymous_object778), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object779), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object780, const char *__anonymous_object781), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object782), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object783, _Bool __anonymous_object784), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object788), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object789), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object790, const char *__anonymous_object791), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object792), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object793, const char *__anonymous_object794), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object795), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object796), __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_object797, const char *__anonymous_object798, unsigned long int __anonymous_object799), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object800, const char *__fmt__PCc_1, ...), void *__anonymous_object801);
    28 void *__sep__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object802), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object803), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object804, _Bool __anonymous_object805), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object806), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object807, const char *__anonymous_object808), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object809), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object810, _Bool __anonymous_object811), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object815), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object816), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object817, const char *__anonymous_object818), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object819), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object820, const char *__anonymous_object821), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object822), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object823), __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_object824, const char *__anonymous_object825, unsigned long int __anonymous_object826), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object827, const char *__fmt__PCc_1, ...), void *__anonymous_object828);
    29 void *__sepTuple__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object829), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object830), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object831, _Bool __anonymous_object832), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object833), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object834, const char *__anonymous_object835), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object836), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object837, _Bool __anonymous_object838), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object842), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object843), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object844, const char *__anonymous_object845), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object846), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object847, const char *__anonymous_object848), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object849), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object850), __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_object851, const char *__anonymous_object852, unsigned long int __anonymous_object853), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object854, const char *__fmt__PCc_1, ...), void *__anonymous_object855);
    30 void *__sepOn__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object856), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object857), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object858, _Bool __anonymous_object859), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object860), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object861, const char *__anonymous_object862), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object863), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object864, _Bool __anonymous_object865), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object869), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object870), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object871, const char *__anonymous_object872), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object873), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object874, const char *__anonymous_object875), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object876), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object877), __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_object878, const char *__anonymous_object879, unsigned long int __anonymous_object880), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object881, const char *__fmt__PCc_1, ...), void *__anonymous_object882);
    31 void *__sepOff__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object883), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object884), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object885, _Bool __anonymous_object886), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object887), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object888, const char *__anonymous_object889), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object890), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object891, _Bool __anonymous_object892), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object896), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object897), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object898, const char *__anonymous_object899), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object900), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object901, const char *__anonymous_object902), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object903), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object904), __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_object905, const char *__anonymous_object906, unsigned long int __anonymous_object907), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object908, const char *__fmt__PCc_1, ...), void *__anonymous_object909);
    32 void *__sepDisable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object910), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object911), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object912, _Bool __anonymous_object913), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object914), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object915, const char *__anonymous_object916), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object917), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object918, _Bool __anonymous_object919), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object920), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object921), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object922), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object923), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object924), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object925, const char *__anonymous_object926), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object927), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object928, const char *__anonymous_object929), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object930), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object931), __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_object932, const char *__anonymous_object933, unsigned long int __anonymous_object934), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object935, const char *__fmt__PCc_1, ...), void *__anonymous_object936);
    33 void *__sepEnable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object937), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object939, _Bool __anonymous_object940), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object941), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object942, const char *__anonymous_object943), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object944), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object945, _Bool __anonymous_object946), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object947), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object952, const char *__anonymous_object953), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object954), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object955, const char *__anonymous_object956), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object957), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object958), __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_object959, const char *__anonymous_object960, unsigned long int __anonymous_object961), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object962, const char *__fmt__PCc_1, ...), void *__anonymous_object963);
    34 void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object964)(), void *__anonymous_object965), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object966)(), void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object969)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object970), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object971)(), void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object974)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object975, void *__anonymous_object976), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object977)(), void *__anonymous_object978, void *__anonymous_object979), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object980)(), void *__anonymous_object981, void *__anonymous_object982), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object983)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object984, void *__anonymous_object985), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object986, void *__anonymous_object987), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object988), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object989, void *__anonymous_object990), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object991), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object992, void *__anonymous_object993), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object994), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object995), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object996, _Bool __anonymous_object997), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object998), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object999, const char *__anonymous_object1000), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1002, _Bool __anonymous_object1003), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1004), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1005), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1009, const char *__anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1015), __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_object1016, const char *__anonymous_object1017, unsigned long int __anonymous_object1018), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1019, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1023, void *__anonymous_object1024), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1025), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1026), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1028, void *__anonymous_object1029), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1030, void *__anonymous_object1031), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1032), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
    35 void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1033)(), void *__anonymous_object1034), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1035)(), void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1038)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1039), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1040)(), void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1043)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1044, void *__anonymous_object1045), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1046)(), void *__anonymous_object1047, void *__anonymous_object1048), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1049)(), void *__anonymous_object1050, void *__anonymous_object1051), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1052)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1053, void *__anonymous_object1054), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1055, void *__anonymous_object1056), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1060), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1061, void *__anonymous_object1062), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1063), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1064), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1065, _Bool __anonymous_object1066), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1068, const char *__anonymous_object1069), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1070), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1071, _Bool __anonymous_object1072), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1073), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1074), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1075), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1076), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1078, const char *__anonymous_object1079), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1080), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1081, const char *__anonymous_object1082), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1083), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1084), __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_object1085, const char *__anonymous_object1086, unsigned long int __anonymous_object1087), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1088, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1092, void *__anonymous_object1093), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1094), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1095), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1097, void *__anonymous_object1098), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1099, void *__anonymous_object1100), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1101), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
    36 void *___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_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1102), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1103), __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_object1104, char *__anonymous_object1105, unsigned long int __anonymous_object1106), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1107, char __anonymous_object1108), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1109, const char *__fmt__PCc_1, ...), void *__anonymous_object1110, char *__anonymous_object1111);
    37 void *___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_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1112), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1113), __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_object1114, char *__anonymous_object1115, unsigned long int __anonymous_object1116), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1117, char __anonymous_object1118), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1119, const char *__fmt__PCc_1, ...), void *__anonymous_object1120, signed char *__anonymous_object1121);
    38 void *___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_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1122), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1123), __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_object1124, char *__anonymous_object1125, unsigned long int __anonymous_object1126), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1127, char __anonymous_object1128), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1129, const char *__fmt__PCc_1, ...), void *__anonymous_object1130, unsigned char *__anonymous_object1131);
    39 void *___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_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1132), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1133), __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_object1134, char *__anonymous_object1135, unsigned long int __anonymous_object1136), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1137, char __anonymous_object1138), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1139, const char *__fmt__PCc_1, ...), void *__anonymous_object1140, signed short int *__anonymous_object1141);
    40 void *___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_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1142), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1143), __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_object1144, char *__anonymous_object1145, unsigned long int __anonymous_object1146), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1147, char __anonymous_object1148), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1149, const char *__fmt__PCc_1, ...), void *__anonymous_object1150, unsigned short int *__anonymous_object1151);
    41 void *___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_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1152), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1153), __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_object1154, char *__anonymous_object1155, unsigned long int __anonymous_object1156), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1157, char __anonymous_object1158), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1159, const char *__fmt__PCc_1, ...), void *__anonymous_object1160, signed int *__anonymous_object1161);
    42 void *___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_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1162), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1163), __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_object1164, char *__anonymous_object1165, unsigned long int __anonymous_object1166), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1167, char __anonymous_object1168), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1169, const char *__fmt__PCc_1, ...), void *__anonymous_object1170, unsigned int *__anonymous_object1171);
    43 void *___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_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1172), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1173), __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_object1174, char *__anonymous_object1175, unsigned long int __anonymous_object1176), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1177, char __anonymous_object1178), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1179, const char *__fmt__PCc_1, ...), void *__anonymous_object1180, signed long int *__anonymous_object1181);
    44 void *___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_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1182), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1183), __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_object1184, char *__anonymous_object1185, unsigned long int __anonymous_object1186), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1187, char __anonymous_object1188), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1189, const char *__fmt__PCc_1, ...), void *__anonymous_object1190, signed long long int *__anonymous_object1191);
    45 void *___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_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1192), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1193), __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_object1194, char *__anonymous_object1195, unsigned long int __anonymous_object1196), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1197, char __anonymous_object1198), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1199, const char *__fmt__PCc_1, ...), void *__anonymous_object1200, unsigned long int *__anonymous_object1201);
    46 void *___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_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1202), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1203), __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_object1204, char *__anonymous_object1205, unsigned long int __anonymous_object1206), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1207, char __anonymous_object1208), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1209, const char *__fmt__PCc_1, ...), void *__anonymous_object1210, unsigned long long int *__anonymous_object1211);
    47 void *___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_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1212), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1213), __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_object1214, char *__anonymous_object1215, unsigned long int __anonymous_object1216), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1217, char __anonymous_object1218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1219, const char *__fmt__PCc_1, ...), void *__anonymous_object1220, float *__anonymous_object1221);
    48 void *___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_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1222), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1223), __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_object1224, char *__anonymous_object1225, unsigned long int __anonymous_object1226), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1227, char __anonymous_object1228), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1229, const char *__fmt__PCc_1, ...), void *__anonymous_object1230, double *__anonymous_object1231);
    49 void *___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_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1232), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1233), __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_object1234, char *__anonymous_object1235, unsigned long int __anonymous_object1236), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1237, char __anonymous_object1238), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1239, const char *__fmt__PCc_1, ...), void *__anonymous_object1240, long double *__anonymous_object1241);
    50 void *___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_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1242), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1243), __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_object1244, char *__anonymous_object1245, unsigned long int __anonymous_object1246), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1247, char __anonymous_object1248), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1249, const char *__fmt__PCc_1, ...), void *__anonymous_object1250, float _Complex *__anonymous_object1251);
    51 void *___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_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1252), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1253), __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_object1254, char *__anonymous_object1255, unsigned long int __anonymous_object1256), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1257, char __anonymous_object1258), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1259, const char *__fmt__PCc_1, ...), void *__anonymous_object1260, double _Complex *__anonymous_object1261);
    52 void *___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_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1262), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1263), __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_object1264, char *__anonymous_object1265, unsigned long int __anonymous_object1266), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1267, char __anonymous_object1268), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1269, const char *__fmt__PCc_1, ...), void *__anonymous_object1270, long double _Complex *__anonymous_object1271);
     3void *___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_Rd0b__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object103), __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_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, _Bool __anonymous_object109);
     4void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object131), __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_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, char __anonymous_object137);
     5void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object159), __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_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, signed char __anonymous_object165);
     6void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object187), __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_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, unsigned char __anonymous_object193);
     7void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object215), __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_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, signed short int __anonymous_object221);
     8void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object243), __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_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, unsigned short int __anonymous_object249);
     9void *___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_Rd0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object271), __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_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, signed int __anonymous_object277);
     10void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object299), __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_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, unsigned int __anonymous_object305);
     11void *___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_Rd0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object327), __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_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long int __anonymous_object333);
     12void *___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_Rd0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object355), __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_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, signed long long int __anonymous_object361);
     13void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object383), __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_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long int __anonymous_object389);
     14void *___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_Rd0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object411), __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_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, unsigned long long int __anonymous_object417);
     15void *___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_Rd0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object439), __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_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, float __anonymous_object445);
     16void *___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_Rd0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object467), __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_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, double __anonymous_object473);
     17void *___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_Rd0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object495), __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_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, long double __anonymous_object501);
     18void *___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_Rd0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object523), __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_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, float _Complex __anonymous_object529);
     19void *___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_Rd0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object551), __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_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, double _Complex __anonymous_object557);
     20void *___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_Rd0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object579), __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_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, long double _Complex __anonymous_object585);
     21void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object607), __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_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
     22void *___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_Rd0PCUs__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object635), __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_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const unsigned short int *__anonymous_object641);
     23void *___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_Rd0PCUi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object663), __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_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, const unsigned int *__anonymous_object669);
     24void *___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_Rd0PCi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object670), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object672, _Bool __anonymous_object673), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object675, const char *__anonymous_object676), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object677), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object678, _Bool __anonymous_object679), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object680), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object685, const char *__anonymous_object686), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object687), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object688, const char *__anonymous_object689), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object691), __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_object692, const char *__anonymous_object693, unsigned long int __anonymous_object694), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object695, const char *__fmt__PCc_1, ...), void *__anonymous_object696, const signed int *__anonymous_object697);
     25void *___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_Rd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object698), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object699), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object700, _Bool __anonymous_object701), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object703, const char *__anonymous_object704), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object705), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object706, _Bool __anonymous_object707), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object708), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object709), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object713, const char *__anonymous_object714), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object715), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object716, const char *__anonymous_object717), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object719), __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_object720, const char *__anonymous_object721, unsigned long int __anonymous_object722), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object723, const char *__fmt__PCc_1, ...), void *__anonymous_object724, const void *__anonymous_object725);
     26void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_bitor__PFRd0_Rd0tVARGS2__FRd0_Rd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object726)(), void *__anonymous_object727, void *__anonymous_object728), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object729)(), void *__anonymous_object730, void *__anonymous_object731), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object732)(), void *__anonymous_object733, void *__anonymous_object734), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object735)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object736, void *__anonymous_object737), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object738, void *__anonymous_object739), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object741, void *__anonymous_object742), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object743), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype2tT__1)(void *__anonymous_object744, void *__anonymous_object745), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object767), __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_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype7tParams__1)(void *__anonymous_object772, void *__anonymous_object773), void *__os__R7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
     27void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object775), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object776, _Bool __anonymous_object777), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object778), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object779, const char *__anonymous_object780), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object781), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object782, _Bool __anonymous_object783), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object788), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object789, const char *__anonymous_object790), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object791), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object792, const char *__anonymous_object793), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object795), __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_object796, const char *__anonymous_object797, unsigned long int __anonymous_object798), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object799, const char *__fmt__PCc_1, ...), void *__anonymous_object800, void *(*__anonymous_object801)(void *__anonymous_object802));
     28void *__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object803), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object805, _Bool __anonymous_object806), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object808, const char *__anonymous_object809), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object811, _Bool __anonymous_object812), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object815), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object821, const char *__anonymous_object822), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object823), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object824), __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_object825, const char *__anonymous_object826, unsigned long int __anonymous_object827), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object828, const char *__fmt__PCc_1, ...), void *__anonymous_object829);
     29void *__sep__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object830), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object832, _Bool __anonymous_object833), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object835, const char *__anonymous_object836), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object838, _Bool __anonymous_object839), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object842), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object848, const char *__anonymous_object849), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object850), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object851), __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_object852, const char *__anonymous_object853, unsigned long int __anonymous_object854), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object855, const char *__fmt__PCc_1, ...), void *__anonymous_object856);
     30void *__sepTuple__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object857), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object859, _Bool __anonymous_object860), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object862, const char *__anonymous_object863), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object865, _Bool __anonymous_object866), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object869), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object875, const char *__anonymous_object876), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object877), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object878), __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_object879, const char *__anonymous_object880, unsigned long int __anonymous_object881), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object882, const char *__fmt__PCc_1, ...), void *__anonymous_object883);
     31void *__sepOn__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object884), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object886, _Bool __anonymous_object887), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object889, const char *__anonymous_object890), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object892, _Bool __anonymous_object893), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object896), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object902, const char *__anonymous_object903), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object904), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object905), __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_object906, const char *__anonymous_object907, unsigned long int __anonymous_object908), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object909, const char *__fmt__PCc_1, ...), void *__anonymous_object910);
     32void *__sepOff__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object911), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object912), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object913, _Bool __anonymous_object914), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object915), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object916, const char *__anonymous_object917), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object918), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object919, _Bool __anonymous_object920), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object921), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object922), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object923), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object924), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object925), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object926, const char *__anonymous_object927), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object928), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object929, const char *__anonymous_object930), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object931), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object932), __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_object933, const char *__anonymous_object934, unsigned long int __anonymous_object935), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object936, const char *__fmt__PCc_1, ...), void *__anonymous_object937);
     33void *__sepDisable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object959), __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_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), void *__anonymous_object964);
     34void *__sepEnable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object965), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object967, _Bool __anonymous_object968), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object969), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object970, const char *__anonymous_object971), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object972), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object973, _Bool __anonymous_object974), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object975), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object976), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object977), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object978), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object979), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object980, const char *__anonymous_object981), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object982), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object983, const char *__anonymous_object984), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object985), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object986), __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_object987, const char *__anonymous_object988, unsigned long int __anonymous_object989), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object990, const char *__fmt__PCc_1, ...), void *__anonymous_object991);
     35void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object992)(), void *__anonymous_object993), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object994)(), void *__anonymous_object995, void *__anonymous_object996), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object997)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object998), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object999)(), void *__anonymous_object1000, void *__anonymous_object1001), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1002)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1003, void *__anonymous_object1004), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1005)(), void *__anonymous_object1006, void *__anonymous_object1007), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1008)(), void *__anonymous_object1009, void *__anonymous_object1010), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1011)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1012, void *__anonymous_object1013), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1014, void *__anonymous_object1015), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1016), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1017, void *__anonymous_object1018), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1019), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1023), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1024, _Bool __anonymous_object1025), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1026), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1027, const char *__anonymous_object1028), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1029), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1030, _Bool __anonymous_object1031), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1032), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1033), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1034), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1035), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1036), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1037, const char *__anonymous_object1038), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1039), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1040, const char *__anonymous_object1041), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1042), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1043), __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_object1044, const char *__anonymous_object1045, unsigned long int __anonymous_object1046), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1047, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1048, void *__anonymous_object1049), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1050), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1051, void *__anonymous_object1052), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1053), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1054), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1055), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1056, void *__anonymous_object1057), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1060), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
     36void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1061)(), void *__anonymous_object1062), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1063)(), void *__anonymous_object1064, void *__anonymous_object1065), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1066)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1067), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1068)(), void *__anonymous_object1069, void *__anonymous_object1070), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1071)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1072, void *__anonymous_object1073), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1074)(), void *__anonymous_object1075, void *__anonymous_object1076), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1077)(), void *__anonymous_object1078, void *__anonymous_object1079), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1080)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1081, void *__anonymous_object1082), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1083, void *__anonymous_object1084), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1085), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1086, void *__anonymous_object1087), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1088), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1092), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1093, _Bool __anonymous_object1094), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1095), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1096, const char *__anonymous_object1097), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1098), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1099, _Bool __anonymous_object1100), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1101), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1102), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1103), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1104), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1105), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1106, const char *__anonymous_object1107), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1108), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1109, const char *__anonymous_object1110), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1111), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1112), __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_object1113, const char *__anonymous_object1114, unsigned long int __anonymous_object1115), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1116, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1117, void *__anonymous_object1118), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1119), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1120, void *__anonymous_object1121), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1122), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1123), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1124), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1125, void *__anonymous_object1126), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1127, void *__anonymous_object1128), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1129), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
     37void *___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_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1130), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1131), __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_object1132, char *__anonymous_object1133, unsigned long int __anonymous_object1134), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1135, char __anonymous_object1136), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1137, const char *__fmt__PCc_1, ...), void *__anonymous_object1138, char *__anonymous_object1139);
     38void *___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_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1140), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1141), __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_object1142, char *__anonymous_object1143, unsigned long int __anonymous_object1144), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1145, char __anonymous_object1146), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1147, const char *__fmt__PCc_1, ...), void *__anonymous_object1148, signed char *__anonymous_object1149);
     39void *___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_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1150), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1151), __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_object1152, char *__anonymous_object1153, unsigned long int __anonymous_object1154), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1155, char __anonymous_object1156), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1157, const char *__fmt__PCc_1, ...), void *__anonymous_object1158, unsigned char *__anonymous_object1159);
     40void *___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_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1160), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1161), __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_object1162, char *__anonymous_object1163, unsigned long int __anonymous_object1164), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1165, char __anonymous_object1166), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1167, const char *__fmt__PCc_1, ...), void *__anonymous_object1168, signed short int *__anonymous_object1169);
     41void *___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_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1170), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1171), __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_object1172, char *__anonymous_object1173, unsigned long int __anonymous_object1174), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1175, char __anonymous_object1176), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1177, const char *__fmt__PCc_1, ...), void *__anonymous_object1178, unsigned short int *__anonymous_object1179);
     42void *___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_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1180), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1181), __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_object1182, char *__anonymous_object1183, unsigned long int __anonymous_object1184), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1185, char __anonymous_object1186), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1187, const char *__fmt__PCc_1, ...), void *__anonymous_object1188, signed int *__anonymous_object1189);
     43void *___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_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1190), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1191), __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_object1192, char *__anonymous_object1193, unsigned long int __anonymous_object1194), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1195, char __anonymous_object1196), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1197, const char *__fmt__PCc_1, ...), void *__anonymous_object1198, unsigned int *__anonymous_object1199);
     44void *___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_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1200), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1201), __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_object1202, char *__anonymous_object1203, unsigned long int __anonymous_object1204), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1205, char __anonymous_object1206), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1207, const char *__fmt__PCc_1, ...), void *__anonymous_object1208, signed long int *__anonymous_object1209);
     45void *___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_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1210), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1211), __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_object1212, char *__anonymous_object1213, unsigned long int __anonymous_object1214), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1215, char __anonymous_object1216), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1217, const char *__fmt__PCc_1, ...), void *__anonymous_object1218, signed long long int *__anonymous_object1219);
     46void *___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_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1220), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1221), __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_object1222, char *__anonymous_object1223, unsigned long int __anonymous_object1224), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1225, char __anonymous_object1226), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1227, const char *__fmt__PCc_1, ...), void *__anonymous_object1228, unsigned long int *__anonymous_object1229);
     47void *___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_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1230), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1231), __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_object1232, char *__anonymous_object1233, unsigned long int __anonymous_object1234), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1235, char __anonymous_object1236), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1237, const char *__fmt__PCc_1, ...), void *__anonymous_object1238, unsigned long long int *__anonymous_object1239);
     48void *___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_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1240), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1241), __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_object1242, char *__anonymous_object1243, unsigned long int __anonymous_object1244), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1245, char __anonymous_object1246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1247, const char *__fmt__PCc_1, ...), void *__anonymous_object1248, float *__anonymous_object1249);
     49void *___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_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1250), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1251), __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_object1252, char *__anonymous_object1253, unsigned long int __anonymous_object1254), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1255, char __anonymous_object1256), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1257, const char *__fmt__PCc_1, ...), void *__anonymous_object1258, double *__anonymous_object1259);
     50void *___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_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1260), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1261), __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_object1262, char *__anonymous_object1263, unsigned long int __anonymous_object1264), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1265, char __anonymous_object1266), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1267, const char *__fmt__PCc_1, ...), void *__anonymous_object1268, long double *__anonymous_object1269);
     51void *___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_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1270), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1271), __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_object1272, char *__anonymous_object1273, unsigned long int __anonymous_object1274), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1275, char __anonymous_object1276), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1277, const char *__fmt__PCc_1, ...), void *__anonymous_object1278, float _Complex *__anonymous_object1279);
     52void *___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_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1280), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1281), __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_object1282, char *__anonymous_object1283, unsigned long int __anonymous_object1284), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1285, char __anonymous_object1286), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1287, const char *__fmt__PCc_1, ...), void *__anonymous_object1288, double _Complex *__anonymous_object1289);
     53void *___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_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1290), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1291), __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_object1292, char *__anonymous_object1293, unsigned long int __anonymous_object1294), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1295, char __anonymous_object1296), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1297, const char *__fmt__PCc_1, ...), void *__anonymous_object1298, long double _Complex *__anonymous_object1299);
    5354struct _Istream_cstrUC {
    5455    char *__s__Pc_1;
    … …  
    7778    ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
    7879}
    79 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1272);
    80 void *___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_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1273), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1274), __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_object1275, char *__anonymous_object1276, unsigned long int __anonymous_object1277), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1278, char __anonymous_object1279), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1280, const char *__fmt__PCc_1, ...), void *__anonymous_object1281, struct _Istream_cstrUC __anonymous_object1282);
     80struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1300);
     81void *___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_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1301), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1302), __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_object1303, char *__anonymous_object1304, unsigned long int __anonymous_object1305), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1306, char __anonymous_object1307), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1308, const char *__fmt__PCc_1, ...), void *__anonymous_object1309, struct _Istream_cstrUC __anonymous_object1310);
    8182struct _Istream_cstrC {
    8283    char *__s__Pc_1;
    … …  
    116117    ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */);
    117118}
    118 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1283, signed int __size__i_1);
    119 void *___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_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1285), __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_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
     119struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1311, signed int __size__i_1);
     120void *___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_object1312), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1313), __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_object1314, char *__anonymous_object1315, unsigned long int __anonymous_object1316), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1317, char __anonymous_object1318), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1319, const char *__fmt__PCc_1, ...), void *__anonymous_object1320, struct _Istream_cstrC __anonymous_object1321);
    120121enum __anonymous0 {
    121122    __sepSize__C13e__anonymous0_1 = 16,
    … …  
    397398
    398399}
    399 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1294);
    400 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1295);
    401 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1296, _Bool __anonymous_object1297);
    402 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1298);
    403 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1299, const char *__anonymous_object1300);
    404 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1301);
    405 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1302, _Bool __anonymous_object1303);
    406 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1304);
    407 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1305);
    408 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1306);
    409 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1307);
    410 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1308);
    411 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1309, const char *__anonymous_object1310);
    412 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1311);
    413 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1312, const char *__anonymous_object1313);
    414 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1314);
    415 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1315);
    416 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1316, const char *__name__PCc_1, const char *__mode__PCc_1);
    417 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1317);
    418 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1318, const char *__data__PCc_1, unsigned long int __size__Ul_1);
    419 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1319, const char *__fmt__PCc_1, ...);
     400_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1322);
     401void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1323);
     402void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1324, _Bool __anonymous_object1325);
     403const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1326);
     404void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1327, const char *__anonymous_object1328);
     405_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1329);
     406void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1330, _Bool __anonymous_object1331);
     407void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1332);
     408void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1333);
     409_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1334);
     410_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1335);
     411const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1336);
     412void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1337, const char *__anonymous_object1338);
     413const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1339);
     414void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1340, const char *__anonymous_object1341);
     415signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1342);
     416signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1343);
     417void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1, const char *__mode__PCc_1);
     418void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1345, const char *__name__PCc_1);
     419void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1346);
     420struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1347, const char *__data__PCc_1, unsigned long int __size__Ul_1);
     421signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1348, const char *__fmt__PCc_1, ...);
    420422void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1);
    421423void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
     424void ___constructor__F_R9sofstreamPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1);
    422425extern struct ofstream *__sout__R9sofstream_1;
    423426extern struct ofstream *__serr__R9sofstream_1;
    … …  
    450453signed int __fail__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
    451454signed int __eof__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
     455void __open__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    452456void __open__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
    453457void __close__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
    454458struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
    455459struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1);
    456 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1320, const char *__fmt__PCc_1, ...);
     460signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1349, const char *__fmt__PCc_1, ...);
    457461void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
     462void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    458463void ___constructor__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
    459464extern struct ifstream *__sin__R9sifstream_1;
    … …  
    463468    struct ofstream *_tmp_cp_ret2;
    464469    __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
    465         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_object1321))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1322))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1323, _Bool __anonymous_object1324))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1325))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1326, const char *__anonymous_object1327))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1328))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1329, _Bool __anonymous_object1330))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1331))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1332))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1333))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1335))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1336, const char *__anonymous_object1337))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1338))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1339, const char *__anonymous_object1340))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1341))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1342))__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_object1343, const char *__anonymous_object1344, unsigned long int __anonymous_object1345))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1346, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    466     }
    467     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1347))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1348))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1349, _Bool __anonymous_object1350))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1351))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1352, const char *__anonymous_object1353))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1354))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1355, _Bool __anonymous_object1356))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1357))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1358))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1359))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1361))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1362, const char *__anonymous_object1363))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1364))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1365, const char *__anonymous_object1366))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1367))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1368))__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_object1369, const char *__anonymous_object1370, unsigned long int __anonymous_object1371))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1372, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((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_object1373))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1374))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1375, _Bool __anonymous_object1376))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1377))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1378, const char *__anonymous_object1379))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1380))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1381, _Bool __anonymous_object1382))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1383))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1384))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1385))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1387))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1388, const char *__anonymous_object1389))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1390))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1391, const char *__anonymous_object1392))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1393))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1394))__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_object1395, const char *__anonymous_object1396, unsigned long int __anonymous_object1397))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1398, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((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_object1399))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1400))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1401, _Bool __anonymous_object1402))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1403))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1404, const char *__anonymous_object1405))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1406))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1407, _Bool __anonymous_object1408))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1409))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1410))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1411))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1413))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1414, const char *__anonymous_object1415))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1416))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1417, const char *__anonymous_object1418))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1419))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1420))__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_object1421, const char *__anonymous_object1422, unsigned long int __anonymous_object1423))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1424, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1425))(&_thunk0)))))) , _tmp_cp_ret2));
     470        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_object1350))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1351))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1352, _Bool __anonymous_object1353))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1354))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1355, const char *__anonymous_object1356))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1357))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1358, _Bool __anonymous_object1359))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1360))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1361))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1363))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1364))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1365, const char *__anonymous_object1366))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1367))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1368, const char *__anonymous_object1369))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1370))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1371))__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_object1372, const char *__anonymous_object1373, unsigned long int __anonymous_object1374))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1375, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     471    }
     472    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1376))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1377))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1378, _Bool __anonymous_object1379))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1380))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1381, const char *__anonymous_object1382))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1383))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1384, _Bool __anonymous_object1385))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1386))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1387))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1389))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1390))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1391, const char *__anonymous_object1392))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1393))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1396))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1397))__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_object1398, const char *__anonymous_object1399, unsigned long int __anonymous_object1400))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1401, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((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_object1402))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1403))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1404, _Bool __anonymous_object1405))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1406))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1407, const char *__anonymous_object1408))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1409))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1410, _Bool __anonymous_object1411))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1412))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1413))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1415))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1416))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1417, const char *__anonymous_object1418))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1419))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1422))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1423))__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_object1424, const char *__anonymous_object1425, unsigned long int __anonymous_object1426))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1427, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((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_object1428))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1429))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1430, _Bool __anonymous_object1431))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1432))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1433, const char *__anonymous_object1434))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1435))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1436, _Bool __anonymous_object1437))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1438))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1439))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1441))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1442))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1443, const char *__anonymous_object1444))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1445))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1448))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1449))__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_object1450, const char *__anonymous_object1451, unsigned long int __anonymous_object1452))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1453, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1454))(&_thunk0)))))) , _tmp_cp_ret2));
    468473}
    469474void __f__F_Sc__1(signed char __v__Sc_1){
    … …  
    472477    struct ofstream *_tmp_cp_ret5;
    473478    __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
    474         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_object1426))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1427))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1428, _Bool __anonymous_object1429))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1430))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1431, const char *__anonymous_object1432))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1433))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1434, _Bool __anonymous_object1435))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1436))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1437))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1438))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1440))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1441, const char *__anonymous_object1442))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1443))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1444, const char *__anonymous_object1445))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1446))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1447))__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_object1448, const char *__anonymous_object1449, unsigned long int __anonymous_object1450))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1451, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    475     }
    476     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1452))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1453))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1454, _Bool __anonymous_object1455))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1456))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1457, const char *__anonymous_object1458))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1459))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1460, _Bool __anonymous_object1461))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1462))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1463))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1464))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1466))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1467, const char *__anonymous_object1468))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1469))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1470, const char *__anonymous_object1471))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1472))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1473))__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_object1474, const char *__anonymous_object1475, unsigned long int __anonymous_object1476))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1477, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1478))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1479))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1480, _Bool __anonymous_object1481))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1482))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1483, const char *__anonymous_object1484))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1485))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1486, _Bool __anonymous_object1487))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1488))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1489))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1490))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1492))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1493, const char *__anonymous_object1494))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1495))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1496, const char *__anonymous_object1497))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1498))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1499))__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_object1500, const char *__anonymous_object1501, unsigned long int __anonymous_object1502))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1503, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1504))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1505))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1506, _Bool __anonymous_object1507))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1508))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1509, const char *__anonymous_object1510))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1511))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1512, _Bool __anonymous_object1513))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1514))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1515))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1516))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1518))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1519, const char *__anonymous_object1520))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1521))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1522, const char *__anonymous_object1523))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1524))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1525))__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_object1526, const char *__anonymous_object1527, unsigned long int __anonymous_object1528))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1529, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1530))(&_thunk1)))))) , _tmp_cp_ret5));
     479        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_object1455))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1456))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1457, _Bool __anonymous_object1458))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1459))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1460, const char *__anonymous_object1461))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1462))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1463, _Bool __anonymous_object1464))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1465))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1466))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1468))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1469))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1470, const char *__anonymous_object1471))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1472))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1473, const char *__anonymous_object1474))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1475))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1476))__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_object1477, const char *__anonymous_object1478, unsigned long int __anonymous_object1479))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1480, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     480    }
     481    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1481))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1482))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1483, _Bool __anonymous_object1484))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1485))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1486, const char *__anonymous_object1487))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1488))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1489, _Bool __anonymous_object1490))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1491))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1492))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1494))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1495))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1496, const char *__anonymous_object1497))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1498))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1501))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1502))__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_object1503, const char *__anonymous_object1504, unsigned long int __anonymous_object1505))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1506, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1507))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1508))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1509, _Bool __anonymous_object1510))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1511))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1512, const char *__anonymous_object1513))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1514))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1515, _Bool __anonymous_object1516))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1517))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1518))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1520))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1521))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1522, const char *__anonymous_object1523))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1524))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1527))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1528))__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_object1529, const char *__anonymous_object1530, unsigned long int __anonymous_object1531))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1532, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1533))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1534))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1535, _Bool __anonymous_object1536))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1537))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1538, const char *__anonymous_object1539))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1540))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1541, _Bool __anonymous_object1542))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1543))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1544))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1546))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1547))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1548, const char *__anonymous_object1549))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1550))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1553))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1554))__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_object1555, const char *__anonymous_object1556, unsigned long int __anonymous_object1557))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1558, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1559))(&_thunk1)))))) , _tmp_cp_ret5));
    477482}
    478483void __f__F_Uc__1(unsigned char __v__Uc_1){
    … …  
    481486    struct ofstream *_tmp_cp_ret8;
    482487    __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
    483         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_object1531))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1532))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1533, _Bool __anonymous_object1534))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1535))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1536, const char *__anonymous_object1537))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1538))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1539, _Bool __anonymous_object1540))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1541))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1542))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1543))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1545))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1546, const char *__anonymous_object1547))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1548))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1549, const char *__anonymous_object1550))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1551))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1552))__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_object1553, const char *__anonymous_object1554, unsigned long int __anonymous_object1555))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1556, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    484     }
    485     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1557))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1558))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1559, _Bool __anonymous_object1560))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1561))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1562, const char *__anonymous_object1563))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1564))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1565, _Bool __anonymous_object1566))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1567))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1568))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1569))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1571))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1572, const char *__anonymous_object1573))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1574))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1575, const char *__anonymous_object1576))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1577))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1578))__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_object1579, const char *__anonymous_object1580, unsigned long int __anonymous_object1581))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1582, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1583))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1584))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1585, _Bool __anonymous_object1586))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1587))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1588, const char *__anonymous_object1589))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1590))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1591, _Bool __anonymous_object1592))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1593))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1594))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1595))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1597))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1598, const char *__anonymous_object1599))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1600))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1601, const char *__anonymous_object1602))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1603))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1604))__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_object1605, const char *__anonymous_object1606, unsigned long int __anonymous_object1607))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1608, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1609))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1610))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1611, _Bool __anonymous_object1612))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1613))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1614, const char *__anonymous_object1615))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1616))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1617, _Bool __anonymous_object1618))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1619))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1620))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1621))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1623))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1624, const char *__anonymous_object1625))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1626))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1627, const char *__anonymous_object1628))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1629))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1630))__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_object1631, const char *__anonymous_object1632, unsigned long int __anonymous_object1633))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1634, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1635))(&_thunk2)))))) , _tmp_cp_ret8));
     488        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_object1560))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1561))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1562, _Bool __anonymous_object1563))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1564))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1565, const char *__anonymous_object1566))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1567))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1568, _Bool __anonymous_object1569))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1570))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1571))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1573))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1574))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1575, const char *__anonymous_object1576))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1577))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1578, const char *__anonymous_object1579))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1580))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1581))__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_object1582, const char *__anonymous_object1583, unsigned long int __anonymous_object1584))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1585, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     489    }
     490    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1586))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1587))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1588, _Bool __anonymous_object1589))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1590))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1591, const char *__anonymous_object1592))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1593))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1594, _Bool __anonymous_object1595))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1596))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1597))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1599))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1600))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1601, const char *__anonymous_object1602))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1603))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1606))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1607))__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_object1608, const char *__anonymous_object1609, unsigned long int __anonymous_object1610))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1611, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1612))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1613))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1614, _Bool __anonymous_object1615))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1616))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1617, const char *__anonymous_object1618))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1619))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1620, _Bool __anonymous_object1621))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1622))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1623))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1625))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1626))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1627, const char *__anonymous_object1628))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1629))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1632))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1633))__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_object1634, const char *__anonymous_object1635, unsigned long int __anonymous_object1636))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1637, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1638))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1639))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1640, _Bool __anonymous_object1641))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1642))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1643, const char *__anonymous_object1644))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1645))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1646, _Bool __anonymous_object1647))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1648))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1649))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1651))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1652))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1653, const char *__anonymous_object1654))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1655))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1658))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1659))__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_object1660, const char *__anonymous_object1661, unsigned long int __anonymous_object1662))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1663, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1664))(&_thunk2)))))) , _tmp_cp_ret8));
    486491}
    487492void __f__F_s__1(signed short int __v__s_1){
    … …  
    490495    struct ofstream *_tmp_cp_ret11;
    491496    __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
    492         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_object1636))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1637))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1638, _Bool __anonymous_object1639))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1640))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1641, const char *__anonymous_object1642))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1643))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1644, _Bool __anonymous_object1645))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1646))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1647))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1648))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1650))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1651, const char *__anonymous_object1652))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1653))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1654, const char *__anonymous_object1655))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1656))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1657))__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_object1658, const char *__anonymous_object1659, unsigned long int __anonymous_object1660))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1661, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    493     }
    494     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1662))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1663))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1664, _Bool __anonymous_object1665))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1666))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1667, const char *__anonymous_object1668))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1669))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1670, _Bool __anonymous_object1671))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1672))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1673))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1674))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1676))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1677, const char *__anonymous_object1678))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1679))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1680, const char *__anonymous_object1681))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1682))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1683))__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_object1684, const char *__anonymous_object1685, unsigned long int __anonymous_object1686))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1687, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0s__1(((_Bool (*)(void *__anonymous_object1688))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1689))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1690, _Bool __anonymous_object1691))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1692))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1693, const char *__anonymous_object1694))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1695))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1696, _Bool __anonymous_object1697))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1698))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1699))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1700))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1702))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1703, const char *__anonymous_object1704))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1705))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1706, const char *__anonymous_object1707))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1708))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1709))__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_object1710, const char *__anonymous_object1711, unsigned long int __anonymous_object1712))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1713, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1714))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1715))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1716, _Bool __anonymous_object1717))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1718))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1719, const char *__anonymous_object1720))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1721))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1722, _Bool __anonymous_object1723))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1724))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1725))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1726))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1728))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1729, const char *__anonymous_object1730))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1731))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1732, const char *__anonymous_object1733))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1734))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1735))__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_object1736, const char *__anonymous_object1737, unsigned long int __anonymous_object1738))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1739, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1740))(&_thunk3)))))) , _tmp_cp_ret11));
     497        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_object1665))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1666))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1667, _Bool __anonymous_object1668))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1669))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1670, const char *__anonymous_object1671))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1672))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1673, _Bool __anonymous_object1674))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1675))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1676))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1678))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1679))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1680, const char *__anonymous_object1681))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1682))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1683, const char *__anonymous_object1684))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1685))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1686))__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_object1687, const char *__anonymous_object1688, unsigned long int __anonymous_object1689))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1690, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     498    }
     499    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1691))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1692))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1693, _Bool __anonymous_object1694))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1695))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1696, const char *__anonymous_object1697))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1698))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1699, _Bool __anonymous_object1700))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1701))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1702))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1704))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1705))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1706, const char *__anonymous_object1707))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1708))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1711))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1712))__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_object1713, const char *__anonymous_object1714, unsigned long int __anonymous_object1715))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1716, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0s__1(((_Bool (*)(void *__anonymous_object1717))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1718))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1719, _Bool __anonymous_object1720))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1721))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1722, const char *__anonymous_object1723))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1724))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1725, _Bool __anonymous_object1726))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1727))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1728))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1730))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1731))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1732, const char *__anonymous_object1733))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1734))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1737))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1738))__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_object1739, const char *__anonymous_object1740, unsigned long int __anonymous_object1741))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1742, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1743))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1744))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1745, _Bool __anonymous_object1746))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1747))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1748, const char *__anonymous_object1749))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1750))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1751, _Bool __anonymous_object1752))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1753))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1754))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1756))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1757))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1758, const char *__anonymous_object1759))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1760))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1763))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1764))__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_object1765, const char *__anonymous_object1766, unsigned long int __anonymous_object1767))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1768, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1769))(&_thunk3)))))) , _tmp_cp_ret11));
    495500}
    496501void __f__F_Us__1(unsigned short int __v__Us_1){
    … …  
    499504    struct ofstream *_tmp_cp_ret14;
    500505    __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
    501         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_object1741))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1742))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1743, _Bool __anonymous_object1744))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1745))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1746, const char *__anonymous_object1747))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1748))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1749, _Bool __anonymous_object1750))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1751))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1752))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1753))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1755))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1756, const char *__anonymous_object1757))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1758))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1759, const char *__anonymous_object1760))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1761))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1762))__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_object1763, const char *__anonymous_object1764, unsigned long int __anonymous_object1765))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1766, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    502     }
    503     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1767))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1768))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1769, _Bool __anonymous_object1770))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1771))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1772, const char *__anonymous_object1773))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1774))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1775, _Bool __anonymous_object1776))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1777))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1778))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1779))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1781))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1782, const char *__anonymous_object1783))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1784))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1785, const char *__anonymous_object1786))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1787))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1788))__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_object1789, const char *__anonymous_object1790, unsigned long int __anonymous_object1791))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1792, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Us__1(((_Bool (*)(void *__anonymous_object1793))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1794))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1795, _Bool __anonymous_object1796))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1797))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1798, const char *__anonymous_object1799))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1800))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1801, _Bool __anonymous_object1802))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1803))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1804))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1805))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1807))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1808, const char *__anonymous_object1809))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1810))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1811, const char *__anonymous_object1812))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1813))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1814))__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_object1815, const char *__anonymous_object1816, unsigned long int __anonymous_object1817))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1818, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1819))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1820))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1821, _Bool __anonymous_object1822))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1823))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1824, const char *__anonymous_object1825))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1826))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1827, _Bool __anonymous_object1828))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1829))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1830))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1831))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1833))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1834, const char *__anonymous_object1835))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1836))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1837, const char *__anonymous_object1838))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1839))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1840))__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_object1841, const char *__anonymous_object1842, unsigned long int __anonymous_object1843))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1844, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1845))(&_thunk4)))))) , _tmp_cp_ret14));
     506        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_object1770))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1771))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1772, _Bool __anonymous_object1773))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1774))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1775, const char *__anonymous_object1776))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1777))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1778, _Bool __anonymous_object1779))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1780))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1781))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1783))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1784))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1785, const char *__anonymous_object1786))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1787))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1788, const char *__anonymous_object1789))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1790))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1791))__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_object1792, const char *__anonymous_object1793, unsigned long int __anonymous_object1794))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1795, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     507    }
     508    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1796))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1797))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1798, _Bool __anonymous_object1799))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1800))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1801, const char *__anonymous_object1802))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1803))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1804, _Bool __anonymous_object1805))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1806))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1807))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1809))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1810))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1811, const char *__anonymous_object1812))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1813))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1816))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1817))__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_object1818, const char *__anonymous_object1819, unsigned long int __anonymous_object1820))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1821, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Us__1(((_Bool (*)(void *__anonymous_object1822))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1823))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1824, _Bool __anonymous_object1825))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1826))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1827, const char *__anonymous_object1828))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1829))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1830, _Bool __anonymous_object1831))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1832))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1833))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1835))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1836))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1837, const char *__anonymous_object1838))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1839))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1842))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1843))__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_object1844, const char *__anonymous_object1845, unsigned long int __anonymous_object1846))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1847, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1848))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1849))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1850, _Bool __anonymous_object1851))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1852))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1853, const char *__anonymous_object1854))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1855))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1856, _Bool __anonymous_object1857))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1858))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1859))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1861))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1862))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1863, const char *__anonymous_object1864))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1865))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1868))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1869))__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_object1870, const char *__anonymous_object1871, unsigned long int __anonymous_object1872))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1873, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1874))(&_thunk4)))))) , _tmp_cp_ret14));
    504509}
    505510void __f__F_Ul__1(unsigned long int __v__Ul_1){
    … …  
    508513    struct ofstream *_tmp_cp_ret17;
    509514    __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
    510         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_object1846))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1847))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1848, _Bool __anonymous_object1849))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1850))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1851, const char *__anonymous_object1852))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1853))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1854, _Bool __anonymous_object1855))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1856))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1857))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1858))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1860))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1861, const char *__anonymous_object1862))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1863))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1864, const char *__anonymous_object1865))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1866))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1867))__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_object1868, const char *__anonymous_object1869, unsigned long int __anonymous_object1870))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1871, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    511     }
    512     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1872))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1873))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1874, _Bool __anonymous_object1875))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1876))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1877, const char *__anonymous_object1878))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1879))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1880, _Bool __anonymous_object1881))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1882))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1883))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1884))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1886))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1887, const char *__anonymous_object1888))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1889))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1890, const char *__anonymous_object1891))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1892))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1893))__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_object1894, const char *__anonymous_object1895, unsigned long int __anonymous_object1896))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1897, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Ul__1(((_Bool (*)(void *__anonymous_object1898))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1899))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1900, _Bool __anonymous_object1901))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1902))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1903, const char *__anonymous_object1904))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1905))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1906, _Bool __anonymous_object1907))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1908))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1909))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1910))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1912))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1913, const char *__anonymous_object1914))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1915))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1916, const char *__anonymous_object1917))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1918))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1919))__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_object1920, const char *__anonymous_object1921, unsigned long int __anonymous_object1922))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1923, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1924))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1925))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1926, _Bool __anonymous_object1927))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1928))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1929, const char *__anonymous_object1930))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1931))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1932, _Bool __anonymous_object1933))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1934))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1935))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1936))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1938))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1939, const char *__anonymous_object1940))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1941))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1942, const char *__anonymous_object1943))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1944))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1945))__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_object1946, const char *__anonymous_object1947, unsigned long int __anonymous_object1948))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1949, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ul_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1950))(&_thunk5)))))) , _tmp_cp_ret17));
     515        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_object1875))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1876))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1877, _Bool __anonymous_object1878))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1879))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1880, const char *__anonymous_object1881))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1882))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1883, _Bool __anonymous_object1884))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1885))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1886))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1888))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1889))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1890, const char *__anonymous_object1891))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1892))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1893, const char *__anonymous_object1894))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1895))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1896))__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_object1897, const char *__anonymous_object1898, unsigned long int __anonymous_object1899))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1900, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     516    }
     517    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1901))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1902))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1903, _Bool __anonymous_object1904))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1905))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1906, const char *__anonymous_object1907))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1908))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1909, _Bool __anonymous_object1910))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1911))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1912))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1914))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1915))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1916, const char *__anonymous_object1917))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1918))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1921))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1922))__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_object1923, const char *__anonymous_object1924, unsigned long int __anonymous_object1925))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1926, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Ul__1(((_Bool (*)(void *__anonymous_object1927))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1928))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1929, _Bool __anonymous_object1930))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1931))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1932, const char *__anonymous_object1933))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1934))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1935, _Bool __anonymous_object1936))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1937))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1938))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1940))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1941))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1942, const char *__anonymous_object1943))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1944))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1947))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1948))__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_object1949, const char *__anonymous_object1950, unsigned long int __anonymous_object1951))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1952, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1953))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1954))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1955, _Bool __anonymous_object1956))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1957))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1958, const char *__anonymous_object1959))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1960))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1961, _Bool __anonymous_object1962))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1963))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1964))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1966))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1967))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1968, const char *__anonymous_object1969))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1970))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1973))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1974))__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_object1975, const char *__anonymous_object1976, unsigned long int __anonymous_object1977))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1978, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ul_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1979))(&_thunk5)))))) , _tmp_cp_ret17));
    513518}
    514519signed int __main__Fi___1(){

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

    rb158d8f rb6838214  
    11void __for_each__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
    22void __for_each_reverse__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
    3 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object103), __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_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, char __anonymous_object109);
    4 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object131), __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_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, signed char __anonymous_object137);
    5 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object159), __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_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, unsigned char __anonymous_object165);
    6 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object187), __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_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, signed short int __anonymous_object193);
    7 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object215), __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_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, unsigned short int __anonymous_object221);
    8 void *___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_Rd0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object243), __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_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, signed int __anonymous_object249);
    9 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object271), __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_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, unsigned int __anonymous_object277);
    10 void *___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_Rd0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object299), __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_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, signed long int __anonymous_object305);
    11 void *___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_Rd0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object327), __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_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long long int __anonymous_object333);
    12 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object355), __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_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, unsigned long int __anonymous_object361);
    13 void *___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_Rd0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object383), __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_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long long int __anonymous_object389);
    14 void *___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_Rd0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object411), __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_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, float __anonymous_object417);
    15 void *___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_Rd0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object439), __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_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, double __anonymous_object445);
    16 void *___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_Rd0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object467), __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_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, long double __anonymous_object473);
    17 void *___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_Rd0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object495), __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_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, float _Complex __anonymous_object501);
    18 void *___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_Rd0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object523), __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_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, double _Complex __anonymous_object529);
    19 void *___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_Rd0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object551), __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_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, long double _Complex __anonymous_object557);
    20 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object579), __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_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, const char *__anonymous_object585);
    21 void *___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_Rd0PCUs__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object607), __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_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const unsigned short int *__anonymous_object613);
    22 void *___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_Rd0PCUi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object635), __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_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const unsigned int *__anonymous_object641);
    23 void *___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_Rd0PCl__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object663), __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_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, const signed long int *__anonymous_object669);
    24 void *___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_Rd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object670), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object672, _Bool __anonymous_object673), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object675, const char *__anonymous_object676), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object677), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object678, _Bool __anonymous_object679), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object680), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object685, const char *__anonymous_object686), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object687), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object688, const char *__anonymous_object689), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object691), __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_object692, const char *__anonymous_object693, unsigned long int __anonymous_object694), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object695, const char *__fmt__PCc_1, ...), void *__anonymous_object696, const void *__anonymous_object697);
    25 void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_bitor__PFRd0_Rd0tVARGS2__FRd0_Rd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object698)(), void *__anonymous_object699, void *__anonymous_object700), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object701)(), void *__anonymous_object702, void *__anonymous_object703), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object704)(), void *__anonymous_object705, void *__anonymous_object706), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object707)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object708, void *__anonymous_object709), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object710, void *__anonymous_object711), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object713, void *__anonymous_object714), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object715), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype2tT__1)(void *__anonymous_object716, void *__anonymous_object717), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object720, _Bool __anonymous_object721), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object722), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object723, const char *__anonymous_object724), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object726, _Bool __anonymous_object727), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object728), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object733, const char *__anonymous_object734), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object736, const char *__anonymous_object737), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object739), __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_object740, const char *__anonymous_object741, unsigned long int __anonymous_object742), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object743, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype7tParams__1)(void *__anonymous_object744, void *__anonymous_object745), void *__os__R7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
    26 void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object767), __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_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772, void *(*__anonymous_object773)(void *__anonymous_object774));
    27 void *__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object775), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object776), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object777, _Bool __anonymous_object778), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object779), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object780, const char *__anonymous_object781), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object782), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object783, _Bool __anonymous_object784), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object788), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object789), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object790, const char *__anonymous_object791), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object792), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object793, const char *__anonymous_object794), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object795), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object796), __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_object797, const char *__anonymous_object798, unsigned long int __anonymous_object799), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object800, const char *__fmt__PCc_1, ...), void *__anonymous_object801);
    28 void *__sep__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object802), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object803), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object804, _Bool __anonymous_object805), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object806), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object807, const char *__anonymous_object808), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object809), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object810, _Bool __anonymous_object811), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object815), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object816), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object817, const char *__anonymous_object818), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object819), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object820, const char *__anonymous_object821), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object822), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object823), __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_object824, const char *__anonymous_object825, unsigned long int __anonymous_object826), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object827, const char *__fmt__PCc_1, ...), void *__anonymous_object828);
    29 void *__sepTuple__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object829), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object830), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object831, _Bool __anonymous_object832), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object833), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object834, const char *__anonymous_object835), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object836), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object837, _Bool __anonymous_object838), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object842), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object843), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object844, const char *__anonymous_object845), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object846), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object847, const char *__anonymous_object848), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object849), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object850), __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_object851, const char *__anonymous_object852, unsigned long int __anonymous_object853), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object854, const char *__fmt__PCc_1, ...), void *__anonymous_object855);
    30 void *__sepOn__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object856), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object857), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object858, _Bool __anonymous_object859), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object860), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object861, const char *__anonymous_object862), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object863), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object864, _Bool __anonymous_object865), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object869), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object870), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object871, const char *__anonymous_object872), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object873), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object874, const char *__anonymous_object875), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object876), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object877), __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_object878, const char *__anonymous_object879, unsigned long int __anonymous_object880), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object881, const char *__fmt__PCc_1, ...), void *__anonymous_object882);
    31 void *__sepOff__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object883), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object884), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object885, _Bool __anonymous_object886), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object887), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object888, const char *__anonymous_object889), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object890), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object891, _Bool __anonymous_object892), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object896), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object897), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object898, const char *__anonymous_object899), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object900), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object901, const char *__anonymous_object902), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object903), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object904), __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_object905, const char *__anonymous_object906, unsigned long int __anonymous_object907), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object908, const char *__fmt__PCc_1, ...), void *__anonymous_object909);
    32 void *__sepDisable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object910), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object911), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object912, _Bool __anonymous_object913), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object914), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object915, const char *__anonymous_object916), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object917), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object918, _Bool __anonymous_object919), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object920), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object921), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object922), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object923), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object924), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object925, const char *__anonymous_object926), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object927), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object928, const char *__anonymous_object929), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object930), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object931), __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_object932, const char *__anonymous_object933, unsigned long int __anonymous_object934), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object935, const char *__fmt__PCc_1, ...), void *__anonymous_object936);
    33 void *__sepEnable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object937), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object939, _Bool __anonymous_object940), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object941), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object942, const char *__anonymous_object943), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object944), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object945, _Bool __anonymous_object946), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object947), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object952, const char *__anonymous_object953), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object954), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object955, const char *__anonymous_object956), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object957), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object958), __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_object959, const char *__anonymous_object960, unsigned long int __anonymous_object961), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object962, const char *__fmt__PCc_1, ...), void *__anonymous_object963);
    34 void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object964)(), void *__anonymous_object965), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object966)(), void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object969)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object970), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object971)(), void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object974)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object975, void *__anonymous_object976), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object977)(), void *__anonymous_object978, void *__anonymous_object979), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object980)(), void *__anonymous_object981, void *__anonymous_object982), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object983)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object984, void *__anonymous_object985), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object986, void *__anonymous_object987), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object988), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object989, void *__anonymous_object990), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object991), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object992, void *__anonymous_object993), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object994), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object995), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object996, _Bool __anonymous_object997), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object998), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object999, const char *__anonymous_object1000), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1002, _Bool __anonymous_object1003), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1004), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1005), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1009, const char *__anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1015), __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_object1016, const char *__anonymous_object1017, unsigned long int __anonymous_object1018), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1019, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1023, void *__anonymous_object1024), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1025), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1026), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1028, void *__anonymous_object1029), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1030, void *__anonymous_object1031), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1032), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
    35 void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1033)(), void *__anonymous_object1034), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1035)(), void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1038)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1039), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1040)(), void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1043)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1044, void *__anonymous_object1045), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1046)(), void *__anonymous_object1047, void *__anonymous_object1048), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1049)(), void *__anonymous_object1050, void *__anonymous_object1051), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1052)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1053, void *__anonymous_object1054), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1055, void *__anonymous_object1056), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1060), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1061, void *__anonymous_object1062), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1063), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1064), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1065, _Bool __anonymous_object1066), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1068, const char *__anonymous_object1069), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1070), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1071, _Bool __anonymous_object1072), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1073), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1074), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1075), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1076), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1078, const char *__anonymous_object1079), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1080), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1081, const char *__anonymous_object1082), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1083), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1084), __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_object1085, const char *__anonymous_object1086, unsigned long int __anonymous_object1087), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1088, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1092, void *__anonymous_object1093), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1094), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1095), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1097, void *__anonymous_object1098), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1099, void *__anonymous_object1100), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1101), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
    36 void *___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_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1102), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1103), __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_object1104, char *__anonymous_object1105, unsigned long int __anonymous_object1106), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1107, char __anonymous_object1108), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1109, const char *__fmt__PCc_1, ...), void *__anonymous_object1110, char *__anonymous_object1111);
    37 void *___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_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1112), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1113), __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_object1114, char *__anonymous_object1115, unsigned long int __anonymous_object1116), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1117, char __anonymous_object1118), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1119, const char *__fmt__PCc_1, ...), void *__anonymous_object1120, signed char *__anonymous_object1121);
    38 void *___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_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1122), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1123), __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_object1124, char *__anonymous_object1125, unsigned long int __anonymous_object1126), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1127, char __anonymous_object1128), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1129, const char *__fmt__PCc_1, ...), void *__anonymous_object1130, unsigned char *__anonymous_object1131);
    39 void *___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_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1132), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1133), __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_object1134, char *__anonymous_object1135, unsigned long int __anonymous_object1136), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1137, char __anonymous_object1138), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1139, const char *__fmt__PCc_1, ...), void *__anonymous_object1140, signed short int *__anonymous_object1141);
    40 void *___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_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1142), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1143), __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_object1144, char *__anonymous_object1145, unsigned long int __anonymous_object1146), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1147, char __anonymous_object1148), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1149, const char *__fmt__PCc_1, ...), void *__anonymous_object1150, unsigned short int *__anonymous_object1151);
    41 void *___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_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1152), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1153), __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_object1154, char *__anonymous_object1155, unsigned long int __anonymous_object1156), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1157, char __anonymous_object1158), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1159, const char *__fmt__PCc_1, ...), void *__anonymous_object1160, signed int *__anonymous_object1161);
    42 void *___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_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1162), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1163), __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_object1164, char *__anonymous_object1165, unsigned long int __anonymous_object1166), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1167, char __anonymous_object1168), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1169, const char *__fmt__PCc_1, ...), void *__anonymous_object1170, unsigned int *__anonymous_object1171);
    43 void *___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_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1172), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1173), __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_object1174, char *__anonymous_object1175, unsigned long int __anonymous_object1176), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1177, char __anonymous_object1178), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1179, const char *__fmt__PCc_1, ...), void *__anonymous_object1180, signed long int *__anonymous_object1181);
    44 void *___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_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1182), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1183), __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_object1184, char *__anonymous_object1185, unsigned long int __anonymous_object1186), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1187, char __anonymous_object1188), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1189, const char *__fmt__PCc_1, ...), void *__anonymous_object1190, signed long long int *__anonymous_object1191);
    45 void *___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_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1192), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1193), __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_object1194, char *__anonymous_object1195, unsigned long int __anonymous_object1196), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1197, char __anonymous_object1198), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1199, const char *__fmt__PCc_1, ...), void *__anonymous_object1200, unsigned long int *__anonymous_object1201);
    46 void *___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_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1202), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1203), __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_object1204, char *__anonymous_object1205, unsigned long int __anonymous_object1206), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1207, char __anonymous_object1208), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1209, const char *__fmt__PCc_1, ...), void *__anonymous_object1210, unsigned long long int *__anonymous_object1211);
    47 void *___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_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1212), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1213), __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_object1214, char *__anonymous_object1215, unsigned long int __anonymous_object1216), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1217, char __anonymous_object1218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1219, const char *__fmt__PCc_1, ...), void *__anonymous_object1220, float *__anonymous_object1221);
    48 void *___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_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1222), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1223), __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_object1224, char *__anonymous_object1225, unsigned long int __anonymous_object1226), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1227, char __anonymous_object1228), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1229, const char *__fmt__PCc_1, ...), void *__anonymous_object1230, double *__anonymous_object1231);
    49 void *___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_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1232), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1233), __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_object1234, char *__anonymous_object1235, unsigned long int __anonymous_object1236), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1237, char __anonymous_object1238), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1239, const char *__fmt__PCc_1, ...), void *__anonymous_object1240, long double *__anonymous_object1241);
    50 void *___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_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1242), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1243), __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_object1244, char *__anonymous_object1245, unsigned long int __anonymous_object1246), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1247, char __anonymous_object1248), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1249, const char *__fmt__PCc_1, ...), void *__anonymous_object1250, float _Complex *__anonymous_object1251);
    51 void *___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_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1252), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1253), __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_object1254, char *__anonymous_object1255, unsigned long int __anonymous_object1256), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1257, char __anonymous_object1258), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1259, const char *__fmt__PCc_1, ...), void *__anonymous_object1260, double _Complex *__anonymous_object1261);
    52 void *___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_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1262), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1263), __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_object1264, char *__anonymous_object1265, unsigned long int __anonymous_object1266), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1267, char __anonymous_object1268), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1269, const char *__fmt__PCc_1, ...), void *__anonymous_object1270, long double _Complex *__anonymous_object1271);
     3void *___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_Rd0b__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object103), __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_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, _Bool __anonymous_object109);
     4void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object131), __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_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, char __anonymous_object137);
     5void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object159), __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_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, signed char __anonymous_object165);
     6void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object187), __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_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, unsigned char __anonymous_object193);
     7void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object215), __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_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, signed short int __anonymous_object221);
     8void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object243), __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_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, unsigned short int __anonymous_object249);
     9void *___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_Rd0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object271), __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_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, signed int __anonymous_object277);
     10void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object299), __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_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, unsigned int __anonymous_object305);
     11void *___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_Rd0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object327), __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_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long int __anonymous_object333);
     12void *___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_Rd0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object355), __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_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, signed long long int __anonymous_object361);
     13void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object383), __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_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long int __anonymous_object389);
     14void *___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_Rd0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object411), __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_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, unsigned long long int __anonymous_object417);
     15void *___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_Rd0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object439), __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_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, float __anonymous_object445);
     16void *___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_Rd0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object467), __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_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, double __anonymous_object473);
     17void *___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_Rd0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object495), __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_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, long double __anonymous_object501);
     18void *___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_Rd0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object523), __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_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, float _Complex __anonymous_object529);
     19void *___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_Rd0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object551), __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_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, double _Complex __anonymous_object557);
     20void *___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_Rd0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object579), __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_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, long double _Complex __anonymous_object585);
     21void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object607), __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_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
     22void *___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_Rd0PCUs__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object635), __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_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const unsigned short int *__anonymous_object641);
     23void *___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_Rd0PCUi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object663), __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_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, const unsigned int *__anonymous_object669);
     24void *___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_Rd0PCl__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object670), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object672, _Bool __anonymous_object673), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object675, const char *__anonymous_object676), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object677), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object678, _Bool __anonymous_object679), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object680), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object685, const char *__anonymous_object686), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object687), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object688, const char *__anonymous_object689), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object691), __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_object692, const char *__anonymous_object693, unsigned long int __anonymous_object694), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object695, const char *__fmt__PCc_1, ...), void *__anonymous_object696, const signed long int *__anonymous_object697);
     25void *___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_Rd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object698), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object699), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object700, _Bool __anonymous_object701), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object703, const char *__anonymous_object704), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object705), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object706, _Bool __anonymous_object707), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object708), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object709), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object713, const char *__anonymous_object714), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object715), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object716, const char *__anonymous_object717), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object719), __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_object720, const char *__anonymous_object721, unsigned long int __anonymous_object722), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object723, const char *__fmt__PCc_1, ...), void *__anonymous_object724, const void *__anonymous_object725);
     26void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_bitor__PFRd0_Rd0tVARGS2__FRd0_Rd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object726)(), void *__anonymous_object727, void *__anonymous_object728), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object729)(), void *__anonymous_object730, void *__anonymous_object731), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object732)(), void *__anonymous_object733, void *__anonymous_object734), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object735)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object736, void *__anonymous_object737), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object738, void *__anonymous_object739), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object741, void *__anonymous_object742), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object743), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype2tT__1)(void *__anonymous_object744, void *__anonymous_object745), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object767), __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_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype7tParams__1)(void *__anonymous_object772, void *__anonymous_object773), void *__os__R7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
     27void *___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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object775), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object776, _Bool __anonymous_object777), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object778), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object779, const char *__anonymous_object780), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object781), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object782, _Bool __anonymous_object783), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object788), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object789, const char *__anonymous_object790), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object791), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object792, const char *__anonymous_object793), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object795), __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_object796, const char *__anonymous_object797, unsigned long int __anonymous_object798), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object799, const char *__fmt__PCc_1, ...), void *__anonymous_object800, void *(*__anonymous_object801)(void *__anonymous_object802));
     28void *__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object803), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object805, _Bool __anonymous_object806), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object808, const char *__anonymous_object809), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object811, _Bool __anonymous_object812), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object815), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object821, const char *__anonymous_object822), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object823), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object824), __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_object825, const char *__anonymous_object826, unsigned long int __anonymous_object827), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object828, const char *__fmt__PCc_1, ...), void *__anonymous_object829);
     29void *__sep__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object830), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object832, _Bool __anonymous_object833), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object835, const char *__anonymous_object836), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object838, _Bool __anonymous_object839), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object842), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object848, const char *__anonymous_object849), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object850), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object851), __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_object852, const char *__anonymous_object853, unsigned long int __anonymous_object854), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object855, const char *__fmt__PCc_1, ...), void *__anonymous_object856);
     30void *__sepTuple__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object857), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object859, _Bool __anonymous_object860), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object862, const char *__anonymous_object863), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object865, _Bool __anonymous_object866), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object869), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object875, const char *__anonymous_object876), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object877), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object878), __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_object879, const char *__anonymous_object880, unsigned long int __anonymous_object881), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object882, const char *__fmt__PCc_1, ...), void *__anonymous_object883);
     31void *__sepOn__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object884), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object886, _Bool __anonymous_object887), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object889, const char *__anonymous_object890), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object892, _Bool __anonymous_object893), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object896), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object902, const char *__anonymous_object903), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object904), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object905), __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_object906, const char *__anonymous_object907, unsigned long int __anonymous_object908), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object909, const char *__fmt__PCc_1, ...), void *__anonymous_object910);
     32void *__sepOff__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object911), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object912), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object913, _Bool __anonymous_object914), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object915), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object916, const char *__anonymous_object917), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object918), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object919, _Bool __anonymous_object920), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object921), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object922), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object923), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object924), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object925), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object926, const char *__anonymous_object927), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object928), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object929, const char *__anonymous_object930), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object931), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object932), __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_object933, const char *__anonymous_object934, unsigned long int __anonymous_object935), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object936, const char *__fmt__PCc_1, ...), void *__anonymous_object937);
     33void *__sepDisable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object959), __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_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), void *__anonymous_object964);
     34void *__sepEnable__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(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object965), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object967, _Bool __anonymous_object968), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object969), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object970, const char *__anonymous_object971), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object972), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object973, _Bool __anonymous_object974), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object975), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object976), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object977), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object978), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object979), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object980, const char *__anonymous_object981), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object982), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object983, const char *__anonymous_object984), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object985), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object986), __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_object987, const char *__anonymous_object988, unsigned long int __anonymous_object989), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object990, const char *__fmt__PCc_1, ...), void *__anonymous_object991);
     35void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object992)(), void *__anonymous_object993), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object994)(), void *__anonymous_object995, void *__anonymous_object996), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object997)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object998), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object999)(), void *__anonymous_object1000, void *__anonymous_object1001), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1002)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1003, void *__anonymous_object1004), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1005)(), void *__anonymous_object1006, void *__anonymous_object1007), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1008)(), void *__anonymous_object1009, void *__anonymous_object1010), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1011)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1012, void *__anonymous_object1013), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1014, void *__anonymous_object1015), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1016), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1017, void *__anonymous_object1018), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1019), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1023), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1024, _Bool __anonymous_object1025), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1026), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1027, const char *__anonymous_object1028), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1029), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1030, _Bool __anonymous_object1031), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1032), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1033), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1034), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1035), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1036), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1037, const char *__anonymous_object1038), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1039), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1040, const char *__anonymous_object1041), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1042), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1043), __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_object1044, const char *__anonymous_object1045, unsigned long int __anonymous_object1046), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1047, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1048, void *__anonymous_object1049), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1050), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1051, void *__anonymous_object1052), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1053), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1054), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1055), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1056, void *__anonymous_object1057), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1060), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
     36void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___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____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1061)(), void *__anonymous_object1062), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1063)(), void *__anonymous_object1064, void *__anonymous_object1065), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1066)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1067), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1068)(), void *__anonymous_object1069, void *__anonymous_object1070), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1071)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1072, void *__anonymous_object1073), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1074)(), void *__anonymous_object1075, void *__anonymous_object1076), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1077)(), void *__anonymous_object1078, void *__anonymous_object1079), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1080)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1081, void *__anonymous_object1082), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1083, void *__anonymous_object1084), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1085), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1086, void *__anonymous_object1087), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1088), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1092), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1093, _Bool __anonymous_object1094), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1095), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1096, const char *__anonymous_object1097), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1098), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1099, _Bool __anonymous_object1100), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1101), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1102), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1103), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1104), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1105), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1106, const char *__anonymous_object1107), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1108), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1109, const char *__anonymous_object1110), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1111), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1112), __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_object1113, const char *__anonymous_object1114, unsigned long int __anonymous_object1115), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1116, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1117, void *__anonymous_object1118), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1119), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1120, void *__anonymous_object1121), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1122), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1123), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1124), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1125, void *__anonymous_object1126), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1127, void *__anonymous_object1128), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1129), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
     37void *___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_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1130), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1131), __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_object1132, char *__anonymous_object1133, unsigned long int __anonymous_object1134), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1135, char __anonymous_object1136), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1137, const char *__fmt__PCc_1, ...), void *__anonymous_object1138, char *__anonymous_object1139);
     38void *___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_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1140), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1141), __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_object1142, char *__anonymous_object1143, unsigned long int __anonymous_object1144), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1145, char __anonymous_object1146), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1147, const char *__fmt__PCc_1, ...), void *__anonymous_object1148, signed char *__anonymous_object1149);
     39void *___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_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1150), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1151), __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_object1152, char *__anonymous_object1153, unsigned long int __anonymous_object1154), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1155, char __anonymous_object1156), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1157, const char *__fmt__PCc_1, ...), void *__anonymous_object1158, unsigned char *__anonymous_object1159);
     40void *___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_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1160), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1161), __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_object1162, char *__anonymous_object1163, unsigned long int __anonymous_object1164), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1165, char __anonymous_object1166), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1167, const char *__fmt__PCc_1, ...), void *__anonymous_object1168, signed short int *__anonymous_object1169);
     41void *___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_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1170), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1171), __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_object1172, char *__anonymous_object1173, unsigned long int __anonymous_object1174), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1175, char __anonymous_object1176), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1177, const char *__fmt__PCc_1, ...), void *__anonymous_object1178, unsigned short int *__anonymous_object1179);
     42void *___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_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1180), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1181), __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_object1182, char *__anonymous_object1183, unsigned long int __anonymous_object1184), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1185, char __anonymous_object1186), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1187, const char *__fmt__PCc_1, ...), void *__anonymous_object1188, signed int *__anonymous_object1189);
     43void *___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_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1190), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1191), __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_object1192, char *__anonymous_object1193, unsigned long int __anonymous_object1194), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1195, char __anonymous_object1196), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1197, const char *__fmt__PCc_1, ...), void *__anonymous_object1198, unsigned int *__anonymous_object1199);
     44void *___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_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1200), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1201), __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_object1202, char *__anonymous_object1203, unsigned long int __anonymous_object1204), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1205, char __anonymous_object1206), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1207, const char *__fmt__PCc_1, ...), void *__anonymous_object1208, signed long int *__anonymous_object1209);
     45void *___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_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1210), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1211), __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_object1212, char *__anonymous_object1213, unsigned long int __anonymous_object1214), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1215, char __anonymous_object1216), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1217, const char *__fmt__PCc_1, ...), void *__anonymous_object1218, signed long long int *__anonymous_object1219);
     46void *___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_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1220), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1221), __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_object1222, char *__anonymous_object1223, unsigned long int __anonymous_object1224), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1225, char __anonymous_object1226), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1227, const char *__fmt__PCc_1, ...), void *__anonymous_object1228, unsigned long int *__anonymous_object1229);
     47void *___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_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1230), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1231), __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_object1232, char *__anonymous_object1233, unsigned long int __anonymous_object1234), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1235, char __anonymous_object1236), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1237, const char *__fmt__PCc_1, ...), void *__anonymous_object1238, unsigned long long int *__anonymous_object1239);
     48void *___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_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1240), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1241), __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_object1242, char *__anonymous_object1243, unsigned long int __anonymous_object1244), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1245, char __anonymous_object1246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1247, const char *__fmt__PCc_1, ...), void *__anonymous_object1248, float *__anonymous_object1249);
     49void *___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_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1250), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1251), __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_object1252, char *__anonymous_object1253, unsigned long int __anonymous_object1254), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1255, char __anonymous_object1256), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1257, const char *__fmt__PCc_1, ...), void *__anonymous_object1258, double *__anonymous_object1259);
     50void *___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_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1260), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1261), __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_object1262, char *__anonymous_object1263, unsigned long int __anonymous_object1264), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1265, char __anonymous_object1266), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1267, const char *__fmt__PCc_1, ...), void *__anonymous_object1268, long double *__anonymous_object1269);
     51void *___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_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1270), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1271), __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_object1272, char *__anonymous_object1273, unsigned long int __anonymous_object1274), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1275, char __anonymous_object1276), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1277, const char *__fmt__PCc_1, ...), void *__anonymous_object1278, float _Complex *__anonymous_object1279);
     52void *___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_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1280), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1281), __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_object1282, char *__anonymous_object1283, unsigned long int __anonymous_object1284), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1285, char __anonymous_object1286), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1287, const char *__fmt__PCc_1, ...), void *__anonymous_object1288, double _Complex *__anonymous_object1289);
     53void *___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_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1290), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1291), __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_object1292, char *__anonymous_object1293, unsigned long int __anonymous_object1294), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1295, char __anonymous_object1296), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1297, const char *__fmt__PCc_1, ...), void *__anonymous_object1298, long double _Complex *__anonymous_object1299);
    5354struct _Istream_cstrUC {
    5455    char *__s__Pc_1;
    … …  
    7778    ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
    7879}
    79 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1272);
    80 void *___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_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1273), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1274), __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_object1275, char *__anonymous_object1276, unsigned long int __anonymous_object1277), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1278, char __anonymous_object1279), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1280, const char *__fmt__PCc_1, ...), void *__anonymous_object1281, struct _Istream_cstrUC __anonymous_object1282);
     80struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1300);
     81void *___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_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1301), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1302), __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_object1303, char *__anonymous_object1304, unsigned long int __anonymous_object1305), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1306, char __anonymous_object1307), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1308, const char *__fmt__PCc_1, ...), void *__anonymous_object1309, struct _Istream_cstrUC __anonymous_object1310);
    8182struct _Istream_cstrC {
    8283    char *__s__Pc_1;
    … …  
    116117    ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */);
    117118}
    118 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1283, signed int __size__i_1);
    119 void *___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_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1285), __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_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
     119struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1311, signed int __size__i_1);
     120void *___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_object1312), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1313), __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_object1314, char *__anonymous_object1315, unsigned long int __anonymous_object1316), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1317, char __anonymous_object1318), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1319, const char *__fmt__PCc_1, ...), void *__anonymous_object1320, struct _Istream_cstrC __anonymous_object1321);
    120121enum __anonymous0 {
    121122    __sepSize__C13e__anonymous0_1 = 16,
    … …  
    397398
    398399}
    399 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1294);
    400 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1295);
    401 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1296, _Bool __anonymous_object1297);
    402 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1298);
    403 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1299, const char *__anonymous_object1300);
    404 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1301);
    405 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1302, _Bool __anonymous_object1303);
    406 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1304);
    407 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1305);
    408 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1306);
    409 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1307);
    410 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1308);
    411 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1309, const char *__anonymous_object1310);
    412 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1311);
    413 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1312, const char *__anonymous_object1313);
    414 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1314);
    415 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1315);
    416 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1316, const char *__name__PCc_1, const char *__mode__PCc_1);
    417 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1317);
    418 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1318, const char *__data__PCc_1, unsigned long int __size__Ul_1);
    419 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1319, const char *__fmt__PCc_1, ...);
     400_Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1322);
     401void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1323);
     402void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1324, _Bool __anonymous_object1325);
     403const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1326);
     404void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1327, const char *__anonymous_object1328);
     405_Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1329);
     406void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1330, _Bool __anonymous_object1331);
     407void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1332);
     408void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1333);
     409_Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1334);
     410_Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1335);
     411const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1336);
     412void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1337, const char *__anonymous_object1338);
     413const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1339);
     414void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1340, const char *__anonymous_object1341);
     415signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1342);
     416signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1343);
     417void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1, const char *__mode__PCc_1);
     418void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1345, const char *__name__PCc_1);
     419void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1346);
     420struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1347, const char *__data__PCc_1, unsigned long int __size__Ul_1);
     421signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1348, const char *__fmt__PCc_1, ...);
    420422void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1);
    421423void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
     424void ___constructor__F_R9sofstreamPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1);
    422425extern struct ofstream *__sout__R9sofstream_1;
    423426extern struct ofstream *__serr__R9sofstream_1;
    … …  
    450453signed int __fail__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
    451454signed int __eof__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
     455void __open__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    452456void __open__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
    453457void __close__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
    454458struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
    455459struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1);
    456 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1320, const char *__fmt__PCc_1, ...);
     460signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1349, const char *__fmt__PCc_1, ...);
    457461void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
     462void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
    458463void ___constructor__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
    459464extern struct ifstream *__sin__R9sifstream_1;
    … …  
    463468    struct ofstream *_tmp_cp_ret2;
    464469    __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
    465         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_object1321))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1322))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1323, _Bool __anonymous_object1324))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1325))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1326, const char *__anonymous_object1327))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1328))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1329, _Bool __anonymous_object1330))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1331))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1332))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1333))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1335))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1336, const char *__anonymous_object1337))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1338))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1339, const char *__anonymous_object1340))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1341))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1342))__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_object1343, const char *__anonymous_object1344, unsigned long int __anonymous_object1345))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1346, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    466     }
    467     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1347))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1348))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1349, _Bool __anonymous_object1350))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1351))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1352, const char *__anonymous_object1353))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1354))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1355, _Bool __anonymous_object1356))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1357))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1358))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1359))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1361))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1362, const char *__anonymous_object1363))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1364))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1365, const char *__anonymous_object1366))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1367))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1368))__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_object1369, const char *__anonymous_object1370, unsigned long int __anonymous_object1371))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1372, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((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_object1373))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1374))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1375, _Bool __anonymous_object1376))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1377))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1378, const char *__anonymous_object1379))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1380))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1381, _Bool __anonymous_object1382))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1383))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1384))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1385))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1387))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1388, const char *__anonymous_object1389))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1390))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1391, const char *__anonymous_object1392))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1393))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1394))__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_object1395, const char *__anonymous_object1396, unsigned long int __anonymous_object1397))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1398, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((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_object1399))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1400))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1401, _Bool __anonymous_object1402))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1403))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1404, const char *__anonymous_object1405))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1406))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1407, _Bool __anonymous_object1408))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1409))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1410))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1411))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1413))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1414, const char *__anonymous_object1415))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1416))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1417, const char *__anonymous_object1418))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1419))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1420))__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_object1421, const char *__anonymous_object1422, unsigned long int __anonymous_object1423))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1424, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1425))(&_thunk0)))))) , _tmp_cp_ret2));
     470        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_object1350))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1351))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1352, _Bool __anonymous_object1353))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1354))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1355, const char *__anonymous_object1356))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1357))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1358, _Bool __anonymous_object1359))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1360))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1361))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1363))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1364))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1365, const char *__anonymous_object1366))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1367))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1368, const char *__anonymous_object1369))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1370))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1371))__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_object1372, const char *__anonymous_object1373, unsigned long int __anonymous_object1374))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1375, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     471    }
     472    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1376))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1377))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1378, _Bool __anonymous_object1379))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1380))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1381, const char *__anonymous_object1382))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1383))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1384, _Bool __anonymous_object1385))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1386))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1387))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1389))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1390))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1391, const char *__anonymous_object1392))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1393))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1394, const char *__anonymous_object1395))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1396))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1397))__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_object1398, const char *__anonymous_object1399, unsigned long int __anonymous_object1400))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1401, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=((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_object1402))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1403))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1404, _Bool __anonymous_object1405))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1406))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1407, const char *__anonymous_object1408))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1409))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1410, _Bool __anonymous_object1411))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1412))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1413))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1415))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1416))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1417, const char *__anonymous_object1418))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1419))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1420, const char *__anonymous_object1421))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1422))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1423))__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_object1424, const char *__anonymous_object1425, unsigned long int __anonymous_object1426))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1427, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=((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_object1428))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1429))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1430, _Bool __anonymous_object1431))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1432))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1433, const char *__anonymous_object1434))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1435))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1436, _Bool __anonymous_object1437))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1438))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1439))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1441))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1442))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1443, const char *__anonymous_object1444))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1445))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1446, const char *__anonymous_object1447))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1448))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1449))__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_object1450, const char *__anonymous_object1451, unsigned long int __anonymous_object1452))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1453, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char ")))) , _tmp_cp_ret0)), __v__c_1)))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1454))(&_thunk0)))))) , _tmp_cp_ret2));
    468473}
    469474void __f__F_Sc__1(signed char __v__Sc_1){
    … …  
    472477    struct ofstream *_tmp_cp_ret5;
    473478    __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
    474         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_object1426))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1427))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1428, _Bool __anonymous_object1429))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1430))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1431, const char *__anonymous_object1432))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1433))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1434, _Bool __anonymous_object1435))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1436))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1437))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1438))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1440))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1441, const char *__anonymous_object1442))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1443))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1444, const char *__anonymous_object1445))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1446))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1447))__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_object1448, const char *__anonymous_object1449, unsigned long int __anonymous_object1450))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1451, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    475     }
    476     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1452))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1453))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1454, _Bool __anonymous_object1455))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1456))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1457, const char *__anonymous_object1458))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1459))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1460, _Bool __anonymous_object1461))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1462))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1463))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1464))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1466))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1467, const char *__anonymous_object1468))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1469))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1470, const char *__anonymous_object1471))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1472))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1473))__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_object1474, const char *__anonymous_object1475, unsigned long int __anonymous_object1476))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1477, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1478))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1479))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1480, _Bool __anonymous_object1481))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1482))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1483, const char *__anonymous_object1484))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1485))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1486, _Bool __anonymous_object1487))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1488))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1489))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1490))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1492))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1493, const char *__anonymous_object1494))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1495))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1496, const char *__anonymous_object1497))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1498))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1499))__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_object1500, const char *__anonymous_object1501, unsigned long int __anonymous_object1502))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1503, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1504))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1505))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1506, _Bool __anonymous_object1507))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1508))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1509, const char *__anonymous_object1510))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1511))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1512, _Bool __anonymous_object1513))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1514))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1515))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1516))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1518))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1519, const char *__anonymous_object1520))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1521))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1522, const char *__anonymous_object1523))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1524))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1525))__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_object1526, const char *__anonymous_object1527, unsigned long int __anonymous_object1528))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1529, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1530))(&_thunk1)))))) , _tmp_cp_ret5));
     479        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_object1455))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1456))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1457, _Bool __anonymous_object1458))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1459))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1460, const char *__anonymous_object1461))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1462))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1463, _Bool __anonymous_object1464))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1465))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1466))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1468))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1469))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1470, const char *__anonymous_object1471))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1472))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1473, const char *__anonymous_object1474))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1475))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1476))__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_object1477, const char *__anonymous_object1478, unsigned long int __anonymous_object1479))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1480, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     480    }
     481    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1481))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1482))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1483, _Bool __anonymous_object1484))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1485))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1486, const char *__anonymous_object1487))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1488))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1489, _Bool __anonymous_object1490))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1491))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1492))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1494))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1495))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1496, const char *__anonymous_object1497))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1498))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1499, const char *__anonymous_object1500))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1501))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1502))__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_object1503, const char *__anonymous_object1504, unsigned long int __anonymous_object1505))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1506, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1507))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1508))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1509, _Bool __anonymous_object1510))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1511))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1512, const char *__anonymous_object1513))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1514))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1515, _Bool __anonymous_object1516))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1517))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1518))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1520))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1521))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1522, const char *__anonymous_object1523))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1524))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1525, const char *__anonymous_object1526))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1527))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1528))__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_object1529, const char *__anonymous_object1530, unsigned long int __anonymous_object1531))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1532, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1533))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1534))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1535, _Bool __anonymous_object1536))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1537))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1538, const char *__anonymous_object1539))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1540))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1541, _Bool __anonymous_object1542))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1543))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1544))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1546))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1547))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1548, const char *__anonymous_object1549))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1550))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1551, const char *__anonymous_object1552))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1553))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1554))__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_object1555, const char *__anonymous_object1556, unsigned long int __anonymous_object1557))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1558, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char ")))) , _tmp_cp_ret3)), __v__Sc_1)))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1559))(&_thunk1)))))) , _tmp_cp_ret5));
    477482}
    478483void __f__F_Uc__1(unsigned char __v__Uc_1){
    … …  
    481486    struct ofstream *_tmp_cp_ret8;
    482487    __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
    483         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_object1531))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1532))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1533, _Bool __anonymous_object1534))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1535))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1536, const char *__anonymous_object1537))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1538))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1539, _Bool __anonymous_object1540))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1541))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1542))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1543))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1545))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1546, const char *__anonymous_object1547))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1548))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1549, const char *__anonymous_object1550))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1551))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1552))__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_object1553, const char *__anonymous_object1554, unsigned long int __anonymous_object1555))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1556, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    484     }
    485     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1557))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1558))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1559, _Bool __anonymous_object1560))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1561))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1562, const char *__anonymous_object1563))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1564))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1565, _Bool __anonymous_object1566))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1567))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1568))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1569))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1571))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1572, const char *__anonymous_object1573))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1574))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1575, const char *__anonymous_object1576))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1577))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1578))__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_object1579, const char *__anonymous_object1580, unsigned long int __anonymous_object1581))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1582, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1583))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1584))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1585, _Bool __anonymous_object1586))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1587))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1588, const char *__anonymous_object1589))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1590))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1591, _Bool __anonymous_object1592))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1593))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1594))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1595))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1597))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1598, const char *__anonymous_object1599))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1600))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1601, const char *__anonymous_object1602))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1603))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1604))__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_object1605, const char *__anonymous_object1606, unsigned long int __anonymous_object1607))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1608, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1609))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1610))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1611, _Bool __anonymous_object1612))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1613))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1614, const char *__anonymous_object1615))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1616))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1617, _Bool __anonymous_object1618))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1619))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1620))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1621))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1623))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1624, const char *__anonymous_object1625))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1626))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1627, const char *__anonymous_object1628))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1629))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1630))__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_object1631, const char *__anonymous_object1632, unsigned long int __anonymous_object1633))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1634, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1635))(&_thunk2)))))) , _tmp_cp_ret8));
     488        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_object1560))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1561))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1562, _Bool __anonymous_object1563))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1564))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1565, const char *__anonymous_object1566))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1567))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1568, _Bool __anonymous_object1569))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1570))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1571))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1573))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1574))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1575, const char *__anonymous_object1576))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1577))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1578, const char *__anonymous_object1579))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1580))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1581))__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_object1582, const char *__anonymous_object1583, unsigned long int __anonymous_object1584))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1585, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     489    }
     490    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1586))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1587))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1588, _Bool __anonymous_object1589))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1590))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1591, const char *__anonymous_object1592))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1593))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1594, _Bool __anonymous_object1595))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1596))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1597))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1599))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1600))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1601, const char *__anonymous_object1602))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1603))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1604, const char *__anonymous_object1605))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1606))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1607))__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_object1608, const char *__anonymous_object1609, unsigned long int __anonymous_object1610))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1611, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1612))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1613))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1614, _Bool __anonymous_object1615))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1616))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1617, const char *__anonymous_object1618))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1619))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1620, _Bool __anonymous_object1621))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1622))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1623))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1625))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1626))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1627, const char *__anonymous_object1628))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1629))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1630, const char *__anonymous_object1631))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1632))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1633))__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_object1634, const char *__anonymous_object1635, unsigned long int __anonymous_object1636))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1637, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1638))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1639))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1640, _Bool __anonymous_object1641))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1642))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1643, const char *__anonymous_object1644))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1645))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1646, _Bool __anonymous_object1647))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1648))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1649))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1651))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1652))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1653, const char *__anonymous_object1654))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1655))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1656, const char *__anonymous_object1657))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1658))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1659))__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_object1660, const char *__anonymous_object1661, unsigned long int __anonymous_object1662))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1663, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char ")))) , _tmp_cp_ret6)), __v__Uc_1)))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1664))(&_thunk2)))))) , _tmp_cp_ret8));
    486491}
    487492void __f__F_s__1(signed short int __v__s_1){
    … …  
    490495    struct ofstream *_tmp_cp_ret11;
    491496    __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
    492         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_object1636))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1637))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1638, _Bool __anonymous_object1639))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1640))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1641, const char *__anonymous_object1642))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1643))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1644, _Bool __anonymous_object1645))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1646))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1647))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1648))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1650))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1651, const char *__anonymous_object1652))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1653))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1654, const char *__anonymous_object1655))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1656))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1657))__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_object1658, const char *__anonymous_object1659, unsigned long int __anonymous_object1660))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1661, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    493     }
    494     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1662))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1663))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1664, _Bool __anonymous_object1665))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1666))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1667, const char *__anonymous_object1668))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1669))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1670, _Bool __anonymous_object1671))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1672))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1673))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1674))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1676))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1677, const char *__anonymous_object1678))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1679))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1680, const char *__anonymous_object1681))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1682))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1683))__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_object1684, const char *__anonymous_object1685, unsigned long int __anonymous_object1686))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1687, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0s__1(((_Bool (*)(void *__anonymous_object1688))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1689))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1690, _Bool __anonymous_object1691))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1692))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1693, const char *__anonymous_object1694))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1695))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1696, _Bool __anonymous_object1697))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1698))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1699))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1700))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1702))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1703, const char *__anonymous_object1704))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1705))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1706, const char *__anonymous_object1707))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1708))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1709))__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_object1710, const char *__anonymous_object1711, unsigned long int __anonymous_object1712))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1713, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1714))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1715))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1716, _Bool __anonymous_object1717))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1718))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1719, const char *__anonymous_object1720))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1721))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1722, _Bool __anonymous_object1723))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1724))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1725))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1726))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1728))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1729, const char *__anonymous_object1730))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1731))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1732, const char *__anonymous_object1733))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1734))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1735))__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_object1736, const char *__anonymous_object1737, unsigned long int __anonymous_object1738))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1739, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1740))(&_thunk3)))))) , _tmp_cp_ret11));
     497        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_object1665))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1666))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1667, _Bool __anonymous_object1668))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1669))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1670, const char *__anonymous_object1671))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1672))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1673, _Bool __anonymous_object1674))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1675))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1676))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1678))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1679))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1680, const char *__anonymous_object1681))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1682))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1683, const char *__anonymous_object1684))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1685))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1686))__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_object1687, const char *__anonymous_object1688, unsigned long int __anonymous_object1689))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1690, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     498    }
     499    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1691))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1692))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1693, _Bool __anonymous_object1694))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1695))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1696, const char *__anonymous_object1697))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1698))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1699, _Bool __anonymous_object1700))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1701))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1702))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1704))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1705))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1706, const char *__anonymous_object1707))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1708))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1709, const char *__anonymous_object1710))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1711))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1712))__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_object1713, const char *__anonymous_object1714, unsigned long int __anonymous_object1715))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1716, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0s__1(((_Bool (*)(void *__anonymous_object1717))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1718))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1719, _Bool __anonymous_object1720))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1721))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1722, const char *__anonymous_object1723))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1724))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1725, _Bool __anonymous_object1726))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1727))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1728))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1730))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1731))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1732, const char *__anonymous_object1733))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1734))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1735, const char *__anonymous_object1736))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1737))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1738))__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_object1739, const char *__anonymous_object1740, unsigned long int __anonymous_object1741))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1742, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1743))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1744))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1745, _Bool __anonymous_object1746))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1747))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1748, const char *__anonymous_object1749))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1750))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1751, _Bool __anonymous_object1752))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1753))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1754))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1756))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1757))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1758, const char *__anonymous_object1759))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1760))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1761, const char *__anonymous_object1762))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1763))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1764))__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_object1765, const char *__anonymous_object1766, unsigned long int __anonymous_object1767))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1768, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int")))) , _tmp_cp_ret9)), __v__s_1)))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1769))(&_thunk3)))))) , _tmp_cp_ret11));
    495500}
    496501void __f__F_Us__1(unsigned short int __v__Us_1){
    … …  
    499504    struct ofstream *_tmp_cp_ret14;
    500505    __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
    501         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_object1741))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1742))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1743, _Bool __anonymous_object1744))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1745))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1746, const char *__anonymous_object1747))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1748))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1749, _Bool __anonymous_object1750))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1751))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1752))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1753))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1755))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1756, const char *__anonymous_object1757))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1758))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1759, const char *__anonymous_object1760))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1761))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1762))__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_object1763, const char *__anonymous_object1764, unsigned long int __anonymous_object1765))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1766, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    502     }
    503     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1767))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1768))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1769, _Bool __anonymous_object1770))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1771))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1772, const char *__anonymous_object1773))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1774))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1775, _Bool __anonymous_object1776))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1777))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1778))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1779))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1781))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1782, const char *__anonymous_object1783))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1784))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1785, const char *__anonymous_object1786))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1787))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1788))__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_object1789, const char *__anonymous_object1790, unsigned long int __anonymous_object1791))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1792, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Us__1(((_Bool (*)(void *__anonymous_object1793))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1794))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1795, _Bool __anonymous_object1796))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1797))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1798, const char *__anonymous_object1799))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1800))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1801, _Bool __anonymous_object1802))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1803))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1804))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1805))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1807))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1808, const char *__anonymous_object1809))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1810))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1811, const char *__anonymous_object1812))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1813))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1814))__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_object1815, const char *__anonymous_object1816, unsigned long int __anonymous_object1817))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1818, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1819))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1820))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1821, _Bool __anonymous_object1822))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1823))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1824, const char *__anonymous_object1825))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1826))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1827, _Bool __anonymous_object1828))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1829))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1830))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1831))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1833))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1834, const char *__anonymous_object1835))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1836))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1837, const char *__anonymous_object1838))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1839))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1840))__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_object1841, const char *__anonymous_object1842, unsigned long int __anonymous_object1843))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1844, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1845))(&_thunk4)))))) , _tmp_cp_ret14));
     506        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_object1770))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1771))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1772, _Bool __anonymous_object1773))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1774))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1775, const char *__anonymous_object1776))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1777))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1778, _Bool __anonymous_object1779))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1780))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1781))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1783))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1784))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1785, const char *__anonymous_object1786))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1787))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1788, const char *__anonymous_object1789))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1790))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1791))__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_object1792, const char *__anonymous_object1793, unsigned long int __anonymous_object1794))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1795, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     507    }
     508    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1796))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1797))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1798, _Bool __anonymous_object1799))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1800))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1801, const char *__anonymous_object1802))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1803))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1804, _Bool __anonymous_object1805))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1806))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1807))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1809))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1810))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1811, const char *__anonymous_object1812))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1813))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1814, const char *__anonymous_object1815))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1816))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1817))__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_object1818, const char *__anonymous_object1819, unsigned long int __anonymous_object1820))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1821, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Us__1(((_Bool (*)(void *__anonymous_object1822))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1823))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1824, _Bool __anonymous_object1825))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1826))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1827, const char *__anonymous_object1828))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1829))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1830, _Bool __anonymous_object1831))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1832))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1833))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1835))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1836))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1837, const char *__anonymous_object1838))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1839))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1840, const char *__anonymous_object1841))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1842))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1843))__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_object1844, const char *__anonymous_object1845, unsigned long int __anonymous_object1846))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1847, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1848))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1849))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1850, _Bool __anonymous_object1851))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1852))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1853, const char *__anonymous_object1854))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1855))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1856, _Bool __anonymous_object1857))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1858))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1859))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1861))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1862))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1863, const char *__anonymous_object1864))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1865))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1866, const char *__anonymous_object1867))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1868))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1869))__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_object1870, const char *__anonymous_object1871, unsigned long int __anonymous_object1872))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1873, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int")))) , _tmp_cp_ret12)), __v__Us_1)))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1874))(&_thunk4)))))) , _tmp_cp_ret14));
    504509}
    505510void __f__F_Ui__1(unsigned int __v__Ui_1){
    … …  
    508513    struct ofstream *_tmp_cp_ret17;
    509514    __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
    510         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_object1846))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1847))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1848, _Bool __anonymous_object1849))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1850))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1851, const char *__anonymous_object1852))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1853))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1854, _Bool __anonymous_object1855))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1856))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1857))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1858))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1860))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1861, const char *__anonymous_object1862))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1863))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1864, const char *__anonymous_object1865))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1866))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1867))__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_object1868, const char *__anonymous_object1869, unsigned long int __anonymous_object1870))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1871, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
    511     }
    512     ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1872))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1873))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1874, _Bool __anonymous_object1875))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1876))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1877, const char *__anonymous_object1878))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1879))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1880, _Bool __anonymous_object1881))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1882))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1883))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1884))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1886))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1887, const char *__anonymous_object1888))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1889))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1890, const char *__anonymous_object1891))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1892))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1893))__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_object1894, const char *__anonymous_object1895, unsigned long int __anonymous_object1896))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1897, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Ui__1(((_Bool (*)(void *__anonymous_object1898))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1899))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1900, _Bool __anonymous_object1901))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1902))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1903, const char *__anonymous_object1904))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1905))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1906, _Bool __anonymous_object1907))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1908))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1909))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1910))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1912))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1913, const char *__anonymous_object1914))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1915))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1916, const char *__anonymous_object1917))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1918))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1919))__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_object1920, const char *__anonymous_object1921, unsigned long int __anonymous_object1922))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1923, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1924))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1925))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1926, _Bool __anonymous_object1927))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1928))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1929, const char *__anonymous_object1930))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1931))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1932, _Bool __anonymous_object1933))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1934))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1935))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1936))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1938))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1939, const char *__anonymous_object1940))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1941))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1942, const char *__anonymous_object1943))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1944))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1945))__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_object1946, const char *__anonymous_object1947, unsigned long int __anonymous_object1948))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1949, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ui_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1950))(&_thunk5)))))) , _tmp_cp_ret17));
     515        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_object1875))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1876))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1877, _Bool __anonymous_object1878))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1879))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1880, const char *__anonymous_object1881))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1882))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1883, _Bool __anonymous_object1884))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1885))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1886))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1888))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1889))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1890, const char *__anonymous_object1891))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1892))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1893, const char *__anonymous_object1894))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1895))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1896))__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_object1897, const char *__anonymous_object1898, unsigned long int __anonymous_object1899))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1900, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
     516    }
     517    ((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_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1901))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1902))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1903, _Bool __anonymous_object1904))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1905))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1906, const char *__anonymous_object1907))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1908))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1909, _Bool __anonymous_object1910))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1911))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1912))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1914))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1915))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1916, const char *__anonymous_object1917))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1918))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1919, const char *__anonymous_object1920))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1921))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1922))__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_object1923, const char *__anonymous_object1924, unsigned long int __anonymous_object1925))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1926, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((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_Rd0Ui__1(((_Bool (*)(void *__anonymous_object1927))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1928))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1929, _Bool __anonymous_object1930))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1931))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1932, const char *__anonymous_object1933))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1934))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1935, _Bool __anonymous_object1936))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1937))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1938))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1940))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1941))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1942, const char *__anonymous_object1943))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1944))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1945, const char *__anonymous_object1946))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1947))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1948))__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_object1949, const char *__anonymous_object1950, unsigned long int __anonymous_object1951))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1952, 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_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1953))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1954))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1955, _Bool __anonymous_object1956))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1957))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1958, const char *__anonymous_object1959))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1960))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1961, _Bool __anonymous_object1962))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1963))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1964))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1966))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1967))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1968, const char *__anonymous_object1969))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1970))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1971, const char *__anonymous_object1972))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1973))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1974))__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_object1975, const char *__anonymous_object1976, unsigned long int __anonymous_object1977))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1978, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t")))) , _tmp_cp_ret15)), __v__Ui_1)))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1979))(&_thunk5)))))) , _tmp_cp_ret17));
    513518}
    514519signed int __main__Fi___1(){

  • src/tests/.expect/random.txt

    rb158d8f rb6838214  
    1 ë
    2 1950506212
    3 1626226846
     1õ
     2=
     3V
    44-911259971
    5 1562848336
    6 0.401356
    7 0.573743785402566
    8 0.90158+0.0967396i
    9 0.787170420226857+0.32472417295666i
    10 0.629480269495140021+0.967221734609655215i
     56
     6-4
     71232105397
     80
     918
     10-914096085
     111
     1215
     132077092859
     141
     1511
     160.677254
     170.678106775246139
     180.298107+0.951551i
     190.724141628787955+0.18815430330314i
     200.358747528448063235+0.27913860468074958i

  • src/tests/.expect/searchsort.txt

    rb158d8f rb6838214  
    22
    331, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    4 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
    5 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
    6 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
     410:10, 9:9, 8:8, 7:7, 6:6, 5:5, 4:4, 3:3, 2:2, 1:1,
     510:10, 9:9, 8:8, 7:7, 6:6, 5:5, 4:4, 3:3, 2:2, 1:1,
     610:10, 9:9, 8:8, 7:7, 6:6, 5:5, 4:4, 3:3, 2:2, 1:1,
    77
    881, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    9910, 9, 8, 7, 6, 5, 4, 3, 2, 1,
    10 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
    11 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,
     1010:10, 9:9, 8:8, 7:7, 6:6, 5:5, 4:4, 3:3, 2:2, 1:1,
     1110:10, 9:9, 8:8, 7:7, 6:6, 5:5, 4:4, 3:3, 2:2, 1:1,
    1212
    131310.5, 9.5, 8.5, 7.5, 6.5, 5.5, 4.5, 3.5, 2.5, 1.5,
    14141.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5,
    15 10.5, 9.5, 8.5, 7.5, 6.5, 5.5, 4.5, 3.5, 2.5, 1.5,
    16 10.5, 9.5, 8.5, 7.5, 6.5, 5.5, 4.5, 3.5, 2.5, 1.5,
     1510.5:10.5, 9.5:9.5, 8.5:8.5, 7.5:7.5, 6.5:6.5, 5.5:5.5, 4.5:4.5, 3.5:3.5, 2.5:2.5, 1.5:1.5,
     1610.5:10.5, 9.5:9.5, 8.5:8.5, 7.5:7.5, 6.5:6.5, 5.5:5.5, 4.5:4.5, 3.5:3.5, 2.5:2.5, 1.5:1.5,
    1717
    181810 11, 9 10, 8 9, 7 8, 6 7, 5 6, 4 5, 3 4, 2 3, 1 2,
    19191 2, 2 3, 3 4, 4 5, 5 6, 6 7, 7 8, 8 9, 9 10, 10 11,
    20 10 11, 9 10, 8 9, 7 8, 6 7, 5 6, 4 5, 3 4, 2 3, 1 2,
    21 10 11, 9 10, 8 9, 7 8, 6 7, 5 6, 4 5, 3 4, 2 3, 1 2,
     2010 11:10 11, 9 10:9 10, 8 9:8 9, 7 8:7 8, 6 7:6 7, 5 6:5 6, 4 5:4 5, 3 4:3 4, 2 3:2 3, 1 2:1 2,
     2110 11:10 11, 9 10:9 10, 8 9:8 9, 7 8:7 8, 6 7:6 7, 5 6:5 6, 4 5:4 5, 3 4:3 4, 2 3:2 3, 1 2:1 2,
    2222
     231 2, 2 3, 3 4, 4 5, 5 6, 6 7, 7 8, 8 9, 9 10, 10 11,
     2411:10 11, 10:9 10, 9:8 9, 8:7 8, 7:6 7, 6:5 6, 5:4 5, 4:3 4, 3:2 3, 2:1 2,
     2511:10 11, 10:9 10, 9:8 9, 8:7 8, 7:6 7, 6:5 6, 5:4 5, 4:3 4, 3:2 3, 2:1 2,
     26

  • src/tests/Makefile.am

    rb158d8f rb6838214  
    1717debug=yes
    1818
    19 quick_test=vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
     19quick_test=avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
    2020
    2121if BUILD_CONCURRENCY
    … …  
    4444
    4545.PHONY : list
    46 EXTRA_PROGRAMS = fstream_test vector_test avl_test # build but do not install
     46EXTRA_PROGRAMS = fstream_test avl_test # build but do not install
    4747
    4848fstream_test_SOURCES = fstream_test.c
    4949fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    50 
    51 vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c
    52 vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    5350
    5451avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    … …  
    7673% : %.c @CFA_BINDIR@/@CFA_NAME@
    7774        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@}
    78 
    79 dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
    80         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    81 
    82 dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
    83         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
    8475
    8576declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
    … …  
    110101        ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
    111102
    112 memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@
    113         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    114 
    115 ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
    116         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    117 
    118103completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
    119104        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    … …  
    124109alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
    125110        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     111
     112# Constructor/destructor tests
     113raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
     114        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     115
     116raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
     117        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
     118
     119raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@
     120        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     121
     122raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
     123        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     124

  • src/tests/Makefile.in

    rb158d8f rb6838214  
    9494@BUILD_DEBUG_TRUE@@BUILD_RELEASE_FALSE@am__append_2 = -debug
    9595@BUILD_DEBUG_TRUE@@BUILD_RELEASE_TRUE@am__append_3 = ${DEBUG_FLAGS}
    96 EXTRA_PROGRAMS = fstream_test$(EXEEXT) vector_test$(EXEEXT) \
    97         avl_test$(EXEEXT)
     96EXTRA_PROGRAMS = fstream_test$(EXEEXT) avl_test$(EXEEXT)
    9897subdir = src/tests
    9998ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    … …  
    122121fstream_test_LDADD = $(LDADD)
    123122fstream_test_LINK = $(CCLD) $(fstream_test_CFLAGS) $(CFLAGS) \
    124         $(AM_LDFLAGS) $(LDFLAGS) -o $@
    125 am_vector_test_OBJECTS = vector/vector_test-vector_int.$(OBJEXT) \
    126         vector/vector_test-array.$(OBJEXT) \
    127         vector/vector_test-vector_test.$(OBJEXT)
    128 vector_test_OBJECTS = $(am_vector_test_OBJECTS)
    129 vector_test_LDADD = $(LDADD)
    130 vector_test_LINK = $(CCLD) $(vector_test_CFLAGS) $(CFLAGS) \
    131123        $(AM_LDFLAGS) $(LDFLAGS) -o $@
    132124AM_V_P = $(am__v_P_@AM_V@)
    … …  
    162154am__v_CCLD_0 = @echo "  CCLD    " $@;
    163155am__v_CCLD_1 =
    164 SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \
    165         $(vector_test_SOURCES)
    166 DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES) \
    167         $(vector_test_SOURCES)
     156SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
     157DIST_SOURCES = $(avl_test_SOURCES) $(fstream_test_SOURCES)
    168158am__can_run_installinfo = \
    169159  case $$AM_UPDATE_INFO_DIR in \
    … …  
    313303top_srcdir = @top_srcdir@
    314304debug = yes
    315 quick_test = vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
     305quick_test = avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
    316306@BUILD_CONCURRENCY_FALSE@concurrent = '-Econcurrent'
    317307@BUILD_CONCURRENCY_TRUE@concurrent =
    … …  
    325315fstream_test_SOURCES = fstream_test.c
    326316fstream_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    327 vector_test_SOURCES = vector/vector_int.c vector/array.c vector/vector_test.c
    328 vector_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    329317avl_test_SOURCES = avltree/avl_test.c avltree/avl0.c avltree/avl1.c avltree/avl2.c avltree/avl3.c avltree/avl4.c avltree/avl-private.c
    330318avl_test_CFLAGS = $(if $(test), 2>> $(test), ) ${BUILD_FLAGS}
    … …  
    390378        @rm -f fstream_test$(EXEEXT)
    391379        $(AM_V_CCLD)$(fstream_test_LINK) $(fstream_test_OBJECTS) $(fstream_test_LDADD) $(LIBS)
    392 vector/$(am__dirstamp):
    393         @$(MKDIR_P) vector
    394         @: > vector/$(am__dirstamp)
    395 vector/$(DEPDIR)/$(am__dirstamp):
    396         @$(MKDIR_P) vector/$(DEPDIR)
    397         @: > vector/$(DEPDIR)/$(am__dirstamp)
    398 vector/vector_test-vector_int.$(OBJEXT): vector/$(am__dirstamp) \
    399         vector/$(DEPDIR)/$(am__dirstamp)
    400 vector/vector_test-array.$(OBJEXT): vector/$(am__dirstamp) \
    401         vector/$(DEPDIR)/$(am__dirstamp)
    402 vector/vector_test-vector_test.$(OBJEXT): vector/$(am__dirstamp) \
    403         vector/$(DEPDIR)/$(am__dirstamp)
    404 
    405 vector_test$(EXEEXT): $(vector_test_OBJECTS) $(vector_test_DEPENDENCIES) $(EXTRA_vector_test_DEPENDENCIES)
    406         @rm -f vector_test$(EXEEXT)
    407         $(AM_V_CCLD)$(vector_test_LINK) $(vector_test_OBJECTS) $(vector_test_LDADD) $(LIBS)
    408380
    409381mostlyclean-compile:
    410382        -rm -f *.$(OBJEXT)
    411383        -rm -f avltree/*.$(OBJEXT)
    412         -rm -f vector/*.$(OBJEXT)
    413384
    414385distclean-compile:
    … …  
    423394@AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl_test-avl4.Po@am__quote@
    424395@AMDEP_TRUE@@am__include@ @am__quote@avltree/$(DEPDIR)/avl_test-avl_test.Po@am__quote@
    425 @AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-array.Po@am__quote@
    426 @AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-vector_int.Po@am__quote@
    427 @AMDEP_TRUE@@am__include@ @am__quote@vector/$(DEPDIR)/vector_test-vector_test.Po@am__quote@
    428396
    429397.c.o:
    … …  
    554522@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    555523@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(fstream_test_CFLAGS) $(CFLAGS) -c -o fstream_test-fstream_test.obj `if test -f 'fstream_test.c'; then $(CYGPATH_W) 'fstream_test.c'; else $(CYGPATH_W) '$(srcdir)/fstream_test.c'; fi`
    556 
    557 vector/vector_test-vector_int.o: vector/vector_int.c
    558 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_int.o -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_int.Tpo -c -o vector/vector_test-vector_int.o `test -f 'vector/vector_int.c' || echo '$(srcdir)/'`vector/vector_int.c
    559 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_int.Tpo vector/$(DEPDIR)/vector_test-vector_int.Po
    560 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='vector/vector_int.c' object='vector/vector_test-vector_int.o' libtool=no @AMDEPBACKSLASH@
    561 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    562 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_int.o `test -f 'vector/vector_int.c' || echo '$(srcdir)/'`vector/vector_int.c
    563 
    564 vector/vector_test-vector_int.obj: vector/vector_int.c
    565 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_int.obj -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_int.Tpo -c -o vector/vector_test-vector_int.obj `if test -f 'vector/vector_int.c'; then $(CYGPATH_W) 'vector/vector_int.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_int.c'; fi`
    566 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_int.Tpo vector/$(DEPDIR)/vector_test-vector_int.Po
    567 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='vector/vector_int.c' object='vector/vector_test-vector_int.obj' libtool=no @AMDEPBACKSLASH@
    568 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    569 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_int.obj `if test -f 'vector/vector_int.c'; then $(CYGPATH_W) 'vector/vector_int.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_int.c'; fi`
    570 
    571 vector/vector_test-array.o: vector/array.c
    572 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-array.o -MD -MP -MF vector/$(DEPDIR)/vector_test-array.Tpo -c -o vector/vector_test-array.o `test -f 'vector/array.c' || echo '$(srcdir)/'`vector/array.c
    573 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-array.Tpo vector/$(DEPDIR)/vector_test-array.Po
    574 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='vector/array.c' object='vector/vector_test-array.o' libtool=no @AMDEPBACKSLASH@
    575 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    576 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-array.o `test -f 'vector/array.c' || echo '$(srcdir)/'`vector/array.c
    577 
    578 vector/vector_test-array.obj: vector/array.c
    579 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-array.obj -MD -MP -MF vector/$(DEPDIR)/vector_test-array.Tpo -c -o vector/vector_test-array.obj `if test -f 'vector/array.c'; then $(CYGPATH_W) 'vector/array.c'; else $(CYGPATH_W) '$(srcdir)/vector/array.c'; fi`
    580 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-array.Tpo vector/$(DEPDIR)/vector_test-array.Po
    581 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='vector/array.c' object='vector/vector_test-array.obj' libtool=no @AMDEPBACKSLASH@
    582 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    583 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-array.obj `if test -f 'vector/array.c'; then $(CYGPATH_W) 'vector/array.c'; else $(CYGPATH_W) '$(srcdir)/vector/array.c'; fi`
    584 
    585 vector/vector_test-vector_test.o: vector/vector_test.c
    586 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_test.o -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_test.Tpo -c -o vector/vector_test-vector_test.o `test -f 'vector/vector_test.c' || echo '$(srcdir)/'`vector/vector_test.c
    587 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_test.Tpo vector/$(DEPDIR)/vector_test-vector_test.Po
    588 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='vector/vector_test.c' object='vector/vector_test-vector_test.o' libtool=no @AMDEPBACKSLASH@
    589 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    590 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_test.o `test -f 'vector/vector_test.c' || echo '$(srcdir)/'`vector/vector_test.c
    591 
    592 vector/vector_test-vector_test.obj: vector/vector_test.c
    593 @am__fastdepCC_TRUE@    $(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -MT vector/vector_test-vector_test.obj -MD -MP -MF vector/$(DEPDIR)/vector_test-vector_test.Tpo -c -o vector/vector_test-vector_test.obj `if test -f 'vector/vector_test.c'; then $(CYGPATH_W) 'vector/vector_test.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_test.c'; fi`
    594 @am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) vector/$(DEPDIR)/vector_test-vector_test.Tpo vector/$(DEPDIR)/vector_test-vector_test.Po
    595 @AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='vector/vector_test.c' object='vector/vector_test-vector_test.obj' libtool=no @AMDEPBACKSLASH@
    596 @AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    597 @am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(vector_test_CFLAGS) $(CFLAGS) -c -o vector/vector_test-vector_test.obj `if test -f 'vector/vector_test.c'; then $(CYGPATH_W) 'vector/vector_test.c'; else $(CYGPATH_W) '$(srcdir)/vector/vector_test.c'; fi`
    598524
    599525ID: $(am__tagged_files)
    … …  
    711637        -rm -f avltree/$(DEPDIR)/$(am__dirstamp)
    712638        -rm -f avltree/$(am__dirstamp)
    713         -rm -f vector/$(DEPDIR)/$(am__dirstamp)
    714         -rm -f vector/$(am__dirstamp)
    715639
    716640maintainer-clean-generic:
    … …  
    722646
    723647distclean: distclean-am
    724         -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) vector/$(DEPDIR)
     648        -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
    725649        -rm -f Makefile
    726650distclean-am: clean-am distclean-compile distclean-generic \
    … …  
    768692
    769693maintainer-clean: maintainer-clean-am
    770         -rm -rf ./$(DEPDIR) avltree/$(DEPDIR) vector/$(DEPDIR)
     694        -rm -rf ./$(DEPDIR) avltree/$(DEPDIR)
    771695        -rm -f Makefile
    772696maintainer-clean-am: distclean-am maintainer-clean-generic
    … …  
    827751        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@}
    828752
    829 dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
    830         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    831 
    832 dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
    833         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
    834 
    835753declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
    836754        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
    … …  
    860778        ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
    861779
    862 memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@
    863         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    864 
    865 ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
    866         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    867 
    868780completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
    869781        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    … …  
    873785
    874786alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
     787        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     788
     789# Constructor/destructor tests
     790raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
     791        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     792
     793raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
     794        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
     795
     796raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@
     797        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
     798
     799raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
    875800        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
    876801

  • src/tests/alloc.c

    rb158d8f rb6838214  
    1010// Created On       : Wed Feb  3 07:56:22 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Jul 20 16:01:10 2017
    13 // Update Count     : 318
     12// Last Modified On : Mon Jan 22 21:26:40 2018
     13// Update Count     : 326
    1414//
    1515
    … …  
    1919#include <stdlib.h>                                                                             // posix_memalign
    2020#include <fstream>
    21 #include <stdlib>                                                                                       // access C malloc, realloc
     21#include <stdlib>                                                                               // access C malloc, realloc
    2222
    2323int * foo( int * p, int c ) { return p; }
    … …  
    3232        // allocation, non-array types
    3333
    34         p = (int *)(void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
     34        // int & r = malloc();
     35        // r = 0xdeadbeef;
     36        // printf( "C   malloc %#x\n", r );
     37        // free( &r );
     38
     39        p = (int *)malloc( sizeof(*p) );                                        // C malloc, type unsafe
    3540        *p = 0xdeadbeef;
    3641        printf( "C   malloc %#x\n", *p );
    … …  
    5459        printf( "\n" );
    5560
    56         p = (int *)calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
     61        p = (int *)calloc( dim, sizeof( *p ) );                         // C array calloc, type unsafe
    5762        printf( "C   array calloc, fill 0\n" );
    5863        for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
    … …  
    8388        printf( "\n" );
    8489
    85         p = (int *)(void *)realloc( p, dim * sizeof(*p) );         // C realloc
     90        p = (int *)realloc( p, dim * sizeof(*p) );                      // C realloc
    8691        for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
    8792        printf( "C   realloc\n" );
    … …  
    254259        free( p );
    255260
     261#ifdef ERR1
    256262        stp = malloc();
    257263        printf( "\nSHOULD FAIL\n" );
    258 #ifdef ERR1
    259         p = alloc( stp, dim * sizeof(*stp) );
     264        p = realloc( stp, dim * sizeof( *stp ) );
     265        p = alloc( stp, dim * sizeof( *stp ) );
    260266        p = memset( stp, 10 );
    261267        p = memcpy( &st1, &st );

  • src/tests/ato.c

    rb158d8f rb6838214  
    1010// Created On       : Thu Feb  4 08:10:57 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul  4 23:38:04 2016
    13 // Update Count     : 48
     12// Last Modified On : Thu Nov 16 18:31:56 2017
     13// Update Count     : 89
    1414//
    1515
    … …  
    1818
    1919int main( void ) {
    20         int i = ato( "-123" );
    21         sout | i | "-123" | endl;
    22         unsigned int ui = ato( "123" );
    23         sout | ui | "123" | endl;
    24         long int li = ato( "-123" );
    25         sout | li | "-123" | endl;
    26         unsigned long int uli = ato( "123" );
    27         sout | uli | "123" | endl;
    28         long long int lli = ato( "-123" );
    29         sout | lli | "-123" | endl;
    30         unsigned long long int ulli = ato( "123" );
    31         sout | ulli | "123" | endl;
    32         float f = ato( "-123.456" );
    33         sout | f | "-123.456" | endl;
    34         double d = ato( "-123.4567890123456" );
    35         sout | d | "-123.4567890123456" | endl;
    36         long double ld = ato( "-123.45678901234567890123456789" );
    37         sout | ld | "-123.45678901234567890123456789" | endl;
    38         float _Complex fc = ato( "-123.456-123.456i" );
    39         sout | fc | "-123.456-123.456i" | endl;
    40         double _Complex dc = ato( "-123.4567890123456+123.4567890123456i" );
    41         sout | dc | "-123.4567890123456+123.4567890123456i" | endl;
    42         long double _Complex ldc = ato( "123.45678901234567890123456789-123.45678901234567890123456789i" );
    43         sout | ldc | "123.45678901234567890123456789-123.45678901234567890123456789i" | endl;
    44         long double _Complex ldc2 = ato( "123.45678901234-123.4567890i" );
    45         sout | ldc2 | "123.45678901234-123.4567890i" | endl;
     20        const char * sptr = "-123";
     21        int i = ato( sptr );
     22        sout | i | sptr | endl;
     23        sptr = "123";
     24        unsigned int ui = ato( sptr );
     25        sout | ui | sptr | endl;
     26
     27        sptr = "-123";
     28        long int li = ato( sptr );
     29        sout | li | sptr | endl;
     30        sptr = "123";
     31        unsigned long int uli = ato( sptr );
     32        sout | uli | sptr | endl;
     33
     34        sptr = "-123";
     35        long long int lli = ato( sptr );
     36        sout | lli | sptr | endl;
     37        sptr = "123";
     38        unsigned long long int ulli = ato( sptr );
     39        sout | ulli | sptr | endl;
     40
     41        sptr = "-123.456";
     42        float f = ato( sptr );
     43        sout | f | sptr | endl;
     44        sptr = "-123.4567890123456";
     45        double d = ato( sptr );
     46        sout | d | sptr | endl;
     47        sptr = "-123.45678901234567890123456789";
     48        long double ld = ato( sptr );
     49        sout | ld | sptr | endl;
     50
     51        sptr = "-123.456-123.456i";
     52        float _Complex fc = ato( sptr );
     53        sout | fc | sptr | endl;
     54        sptr = "-123.4567890123456+123.4567890123456i";
     55        double _Complex dc = ato( sptr );
     56        sout | dc | sptr | endl;
     57        sptr = "123.45678901234567890123456789-123.45678901234567890123456789i";
     58        long double _Complex ldc = ato( sptr );
     59        sout | ldc | sptr | endl;
     60        sptr = "123.45678901234-123.4567890i";
     61        long double _Complex ldc2 = ato( sptr );
     62        sout | ldc2 | sptr | endl;
     63
     64
     65        sptr = "-123";
     66        i = strto( sptr, 0, 10 );
     67        sout | i | sptr | endl;
     68        sptr = "123";
     69        ui = strto( sptr, 0, 10 );
     70        sout | ui | sptr | endl;
     71
     72        sptr = "-123";
     73        li = strto( sptr, 0, 10 );
     74        sout | li | sptr | endl;
     75        sptr = "123";
     76        uli = strto( sptr, 0, 10 );
     77        sout | uli | sptr | endl;
     78
     79        sptr = "-123";
     80        lli = strto( sptr, 0, 10 );
     81        sout | lli | sptr | endl;
     82        sptr = "123";
     83        ulli = strto( sptr, 0, 10 );
     84        sout | ulli | sptr | endl;
     85
     86        sptr = "-123.456";
     87        f = strto( sptr, 0 );
     88        sout | f | sptr | endl;
     89        sptr = "-123.4567890123456";
     90        d = strto( sptr, 0 );
     91        sout | d | sptr | endl;
     92        sptr = "-123.45678901234567890123456789";
     93        ld = strto( sptr, 0 );
     94        sout | ld | sptr | endl;
     95
     96        sptr = "-123.456-123.456i";
     97        fc = strto( sptr, 0 );
     98        sout | fc | sptr | endl;
     99
     100        char * eptr = 0;
     101        // sptr = "2fred";
     102        // fc = strto( sptr, &eptr );
     103        // sout | fc | sptr | eptr | endl;
     104
     105        sptr = "2  3";
     106        fc = strto( sptr, &eptr );
     107        sout | fc | sptr | eptr | endl;
     108
     109        sptr = "-123.4567890123456+123.4567890123456i";
     110        dc = strto( sptr, 0 );
     111        sout | dc | sptr | endl;
     112        sptr = "123.45678901234567890123456789-123.45678901234567890123456789i";
     113        ldc = strto( sptr, 0 );
     114        sout | ldc | sptr | endl;
     115        sptr = "123.45678901234-123.4567890i";
     116        ldc2 = strto( sptr, 0 );
     117        sout | ldc2 | sptr | endl;
    46118} // main
    47119

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

    rb158d8f rb6838214  
    88// Created On       : Mon Oct 30 12:45:13 2017
    99// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Tue Dec  5 23:01:51 2017
    11 // Update Count     : 10
     10// Last Modified On : Tue Jan  2 12:18:18 2018
     11// Update Count     : 33
    1212//
    1313
    … …  
    3737        signal( full );
    3838}
     39
    3940int remove( Buffer & mutex buffer ) with( buffer ) {
    4041        if ( count == 0 ) wait( full );
    … …  
    6061        &prod.buffer = buffer;
    6162        prod.N = N;
    62                 }
     63}
    6364
    6465thread Consumer {
    … …  
    9091        processor p;
    9192
    92         //random_seed( getpid() );
    93         random_seed( 1003 );
     93        //srandom( getpid() );
     94        srandom( 1003 );
    9495
    9596        for ( i = 0; i < Cons; i += 1 ) {                       // create consumers

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

    rb158d8f rb6838214  
    88// Created On       : Mon Oct 30 12:56:20 2017
    99// Last Modified By : Peter A. Buhr
    10 // Last Modified On : Wed Dec  6 12:19:19 2017
    11 // Update Count     : 21
     10// Last Modified On : Tue Jan  2 12:19:01 2018
     11// Update Count     : 22
    1212//
    1313
    … …  
    9191        Boy  *boys[NoOfPairs];
    9292
    93         random_seed( /*getpid()*/ 103 );
     93        srandom( /*getpid()*/ 103 );
    9494
    9595        for ( unsigned int i = 0; i < NoOfPairs; i += 1 ) {

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

    rb158d8f rb6838214  
    109109
    110110int main(int argc, char* argv[]) {
    111         random_seed(0);
     111        srandom(0);
    112112        processor p;
    113113        {

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

    rb158d8f rb6838214  
    118118
    119119int main(int argc, char* argv[]) {
    120         random_seed( time( NULL ) );
     120        srandom( time( NULL ) );
    121121        done = false;
    122122        processor p;

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

    rb158d8f rb6838214  
    109109// Main loop
    110110int main(int argc, char* argv[]) {
    111         random_seed( time( NULL ) );
     111        srandom( time( NULL ) );
    112112        all_done = false;
    113113        processor p;

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

    rb158d8f rb6838214  
    127127// Main
    128128int main(int argc, char* argv[]) {
    129         random_seed( time( NULL ) );
     129        srandom( time( NULL ) );
    130130        waiter_left = 4;
    131131        processor p[2];

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

    rb158d8f rb6838214  
    131131
    132132int main() {
    133         random_seed( time(NULL) );
     133        srandom( time(NULL) );
    134134        sout | "Starting" | endl;
    135135        {

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

    rb158d8f rb6838214  
    7474int main(int argc, char* argv[]) {
    7575        done = false;
    76         random_seed( time( NULL ) );
     76        srandom( time( NULL ) );
    7777        printf("%p\n", &globalA);
    7878        sout | "Starting" | endl;

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

    rb158d8f rb6838214  
    7777
    7878int main() {
    79         random_seed( time(NULL) );
     79        srandom( time(NULL) );
    8080        sout | "Starting" | endl;
    8181        {

  • src/tests/coroutine/prodcons.c

    rb158d8f rb6838214  
    1010// Created On       : Mon Sep 18 12:23:39 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Dec  5 22:40:55 2017
    13 // Update Count     : 46
     12// Last Modified On : Tue Jan  2 12:17:01 2018
     13// Update Count     : 47
    1414//
    1515
    … …  
    9090        Prod prod;
    9191        Cons cons = { prod };
    92         random_seed( /* getpid() */ 103 );                                      // fixed seed for testing
     92        srandom( /* getpid() */ 103 );                                          // fixed seed for testing
    9393        start( prod, 5, cons );
    9494        sout | "main stops" | endl;

  • src/tests/raii/.expect/ctor-autogen-ERR1.txt

    rb158d8f rb6838214  
    1 ctor-autogen.c:102:1 error: No reasonable alternatives for expression Applying untyped:
     1raii/ctor-autogen.c:102:1 error: No reasonable alternatives for expression Applying untyped:
    22  Name: ?{}
    33...to:

  • src/tests/random.c

    rb158d8f rb6838214  
    1010// Created On       : Tue Jul  5 21:29:30 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Oct 30 23:06:49 2017
    13 // Update Count     : 6
     12// Last Modified On : Tue Jan  2 12:19:34 2018
     13// Update Count     : 19
    1414//
    1515
    … …  
    1919
    2020int main() {
    21         //srandom( getpid() );                                                          // set random seed
    22         random_seed( 1003 );                                                            // fixed seed for repeatable tests
     21        // srandom( getpid() );                                                         // set random seed
     22        srandom( 1003 );                                                                        // fixed seed for repeatable tests
    2323
    2424        // test polymorphic calls to random and stream
    2525        char c = random();
    2626        sout | c | endl;
     27        c = random( 'A' );
     28        sout | c | endl;
     29        c = random( 'A', 'Z' );
     30        sout | c | endl;
     31
    2732        int i = random();
    2833    sout | i | endl;
     34        i = random( 10 );
     35    sout | i | endl;
     36        i = random( -10, 20 );
     37    sout | i | endl;
     38
    2939        unsigned int ui = random();
    3040    sout | ui | endl;
     41        ui = random( 10u );
     42    sout | ui | endl;
     43        ui = random( 10u, 20u );
     44    sout | ui | endl;
     45
    3146        long int li = random();
    3247    sout | li | endl;
     48        li = random( 10l );
     49    sout | li | endl;
     50        li = random( -10l, 20l );
     51    sout | li | endl;
     52
    3353        unsigned long int uli = random();
    3454    sout | uli | endl;
     55        uli = random( 10ul );
     56    sout | uli | endl;
     57        uli = random( 10ul, 20ul );
     58    sout | uli | endl;
     59
    3560    float f = random();
    3661    sout | f | endl;
     62
    3763    double d = random();
    3864    sout | d | endl;
     65
    3966    float _Complex fc = random();
    4067    sout | fc | endl;
     68
    4169    double _Complex dc = random();
    4270    sout | dc | endl;
     71
    4372    long double _Complex ldc = random();
    4473    sout | ldc | endl;

  • src/tests/searchsort.c

    rb158d8f rb6838214  
    1010// Created On       : Thu Feb  4 18:17:50 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Dec  7 09:14:06 2017
    13 // Update Count     : 77
     12// Last Modified On : Tue Jan  2 08:01:17 2018
     13// Update Count     : 100
    1414//
    1515
    … …  
    3838        for ( unsigned int i = 0; i < size; i += 1 ) {          // C version
    3939                int key = size - i;
    40                 int *v = bsearch( &key, iarr, size, sizeof( iarr[0] ), comp );
    41                 sout | *v | ", ";
     40                int * v = bsearch( &key, iarr, size, sizeof( iarr[0] ), comp );
     41                sout | key | ':' | *v | ", ";
    4242        } // for
    4343        sout | endl;
     44
    4445        for ( unsigned int i = 0; i < size; i += 1 ) {
    45                 int *v = bsearch( size - i, iarr, size );
    46                 sout | *v | ", ";
     46                int * v = bsearch( size - i, iarr, size );
     47                sout | size - i | ':' | *v | ", ";
    4748        } // for
    4849        sout | endl;
    4950        for ( unsigned int i = 0; i < size; i += 1 ) {
    5051                unsigned int posn = bsearch( size - i, iarr, size );
    51                 sout | iarr[posn] | ", ";
     52                sout | size - i | ':' | iarr[posn] | ", ";
    5253        } // for
    5354        sout | endl | endl;
    … …  
    6768                sout | endl;
    6869                for ( unsigned int i = 0; i < size; i += 1 ) {
    69                         int *v = bsearch( size - i, iarr, size );
    70                         sout | *v | ", ";
     70                        int * v = bsearch( size - i, iarr, size );
     71                        sout | size - i | ':' | *v | ", ";
    7172                } // for
    7273                sout | endl;
    7374                for ( unsigned int i = 0; i < size; i += 1 ) {
    7475                        unsigned int posn = bsearch( size - i, iarr, size );
    75                         sout | iarr[posn] | ", ";
     76                        sout | size - i | ':' | iarr[posn] | ", ";
    7677                } // for
    7778        }
    … …  
    9091        sout | endl;
    9192        for ( unsigned int i = 0; i < size; i += 1 ) {
    92                 double *v = bsearch( size - i + 0.5, darr, size );
    93                 sout | *v | ", ";
     93                double * v = bsearch( size - i + 0.5, darr, size );
     94                sout | size - i + 0.5 | ':' | *v | ", ";
    9495        } // for
    9596        sout | endl;
    9697        for ( unsigned int i = 0; i < size; i += 1 ) {
    9798                unsigned int posn = bsearch( size - i + 0.5, darr, size );
    98                 sout | darr[posn] | ", ";
     99                sout | size - i + 0.5 | ':' | darr[posn] | ", ";
    99100        } // for
    100101        sout | endl | endl;
    … …  
    116117        for ( unsigned int i = 0; i < size; i += 1 ) {
    117118                S temp = { size - i, size - i + 1 };
    118                 S *v = bsearch( temp, sarr, size );
    119                 sout | *v | ", ";
     119                S * v = bsearch( temp, sarr, size );
     120                sout | temp | ':' | *v | ", ";
    120121        } // for
    121122        sout | endl;
    … …  
    123124                S temp = { size - i, size - i + 1 };
    124125                unsigned int posn = bsearch( temp, sarr, size );
    125                 sout | sarr[posn] | ", ";
     126                sout | temp | ':' | sarr[posn] | ", ";
    126127        } // for
    127128        sout | endl | endl;
     129        {
     130                unsigned int getKey( const S & s ) { return s.j; }
     131                for ( unsigned int i = 0; i < size; i += 1 ) {
     132                        sout | sarr[i] | ", ";
     133                } // for
     134                sout | endl;
     135                for ( unsigned int i = 0; i < size; i += 1 ) {
     136                        S * v = bsearch( size - i + 1, sarr, size );
     137                        sout | size - i + 1 | ':' | *v | ", ";
     138                } // for
     139                sout | endl;
     140                for ( unsigned int i = 0; i < size; i += 1 ) {
     141                        unsigned int posn = bsearch( size - i + 1, sarr, size );
     142                        sout | size - i + 1 | ':' | sarr[posn] | ", ";
     143                } // for
     144                sout | endl | endl;
     145        }
    128146} // main
    129147

  • src/tests/vector.c

    rb158d8f rb6838214  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // libcfa_vector.c --
     7// vector.c --
    88//
    99// Author           : Thierry Delisle
    1010// Created On       : Mon Jul  4 23:36:19 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  5 15:08:05 2016
    13 // Update Count     : 26
     12// Last Modified On : Thu Jan 18 17:08:08 2018
     13// Update Count     : 27
    1414//
    1515
    … …  
    6363// Local Variables: //
    6464// tab-width: 4 //
    65 // compile-command: "cfa libcfa_vector.c" //
     65// compile-command: "cfa vector.c" //
    6666// End: //
Note: See TracChangeset for help on using the changeset viewer.