From e4b20015a4ee35f1279af4caa983478fa2ff0d4a Mon Sep 17 00:00:00 2001 From: dhuth Date: Mon, 6 Oct 2014 11:56:47 -0600 Subject: Added omega to source --- omega/code_gen/include/code_gen/CG.h | 118 + omega/code_gen/include/code_gen/CG_outputBuilder.h | 177 + omega/code_gen/include/code_gen/CG_outputRepr.h | 31 + omega/code_gen/include/code_gen/CG_roseBuilder.h | 164 + omega/code_gen/include/code_gen/CG_roseRepr.h | 47 + omega/code_gen/include/code_gen/CG_stringBuilder.h | 44 + omega/code_gen/include/code_gen/CG_stringRepr.h | 43 + omega/code_gen/include/code_gen/CG_suifBuilder.h | 88 + omega/code_gen/include/code_gen/CG_suifRepr.h | 36 + omega/code_gen/include/code_gen/CG_utils.h | 45 + omega/code_gen/include/code_gen/code_gen.h | 47 + omega/code_gen/include/code_gen/codegen.h | 44 + omega/code_gen/include/code_gen/codegen_error.h | 15 + omega/code_gen/include/code_gen/cscope.out | 42592 +++++++++ omega/code_gen/include/code_gen/output_repr.h | 46 + omega/code_gen/include/code_gen/rose_attributes.h | 91 + omega/code_gen/obj/Makefile | 49 + omega/code_gen/obj/Makefile.deps | 3934 + omega/code_gen/src/CG.cc | 1163 + omega/code_gen/src/CG_roseBuilder.cc | 1533 + omega/code_gen/src/CG_roseRepr.cc | 176 + omega/code_gen/src/CG_stringBuilder.cc | 487 + omega/code_gen/src/CG_stringRepr.cc | 54 + omega/code_gen/src/CG_suifBuilder.cc | 678 + omega/code_gen/src/CG_suifRepr.cc | 81 + omega/code_gen/src/CG_utils.cc | 1735 + omega/code_gen/src/code_gen.cc | 656 + omega/code_gen/src/codegen.cc | 378 + omega/code_gen/src/cscope.out | 89773 +++++++++++++++++++ omega/code_gen/src/output_repr.cc | 1931 + omega/code_gen/src/rose_attributes.cc | 183 + omega/code_gen/src/tags | 158 + 32 files changed, 146597 insertions(+) create mode 100644 omega/code_gen/include/code_gen/CG.h create mode 100644 omega/code_gen/include/code_gen/CG_outputBuilder.h create mode 100644 omega/code_gen/include/code_gen/CG_outputRepr.h create mode 100644 omega/code_gen/include/code_gen/CG_roseBuilder.h create mode 100644 omega/code_gen/include/code_gen/CG_roseRepr.h create mode 100644 omega/code_gen/include/code_gen/CG_stringBuilder.h create mode 100644 omega/code_gen/include/code_gen/CG_stringRepr.h create mode 100644 omega/code_gen/include/code_gen/CG_suifBuilder.h create mode 100644 omega/code_gen/include/code_gen/CG_suifRepr.h create mode 100755 omega/code_gen/include/code_gen/CG_utils.h create mode 100644 omega/code_gen/include/code_gen/code_gen.h create mode 100755 omega/code_gen/include/code_gen/codegen.h create mode 100755 omega/code_gen/include/code_gen/codegen_error.h create mode 100644 omega/code_gen/include/code_gen/cscope.out create mode 100644 omega/code_gen/include/code_gen/output_repr.h create mode 100644 omega/code_gen/include/code_gen/rose_attributes.h create mode 100644 omega/code_gen/obj/Makefile create mode 100644 omega/code_gen/obj/Makefile.deps create mode 100644 omega/code_gen/src/CG.cc create mode 100644 omega/code_gen/src/CG_roseBuilder.cc create mode 100644 omega/code_gen/src/CG_roseRepr.cc create mode 100644 omega/code_gen/src/CG_stringBuilder.cc create mode 100644 omega/code_gen/src/CG_stringRepr.cc create mode 100644 omega/code_gen/src/CG_suifBuilder.cc create mode 100644 omega/code_gen/src/CG_suifRepr.cc create mode 100755 omega/code_gen/src/CG_utils.cc create mode 100644 omega/code_gen/src/code_gen.cc create mode 100755 omega/code_gen/src/codegen.cc create mode 100644 omega/code_gen/src/cscope.out create mode 100644 omega/code_gen/src/output_repr.cc create mode 100644 omega/code_gen/src/rose_attributes.cc create mode 100644 omega/code_gen/src/tags (limited to 'omega/code_gen') diff --git a/omega/code_gen/include/code_gen/CG.h b/omega/code_gen/include/code_gen/CG.h new file mode 100644 index 0000000..4054d82 --- /dev/null +++ b/omega/code_gen/include/code_gen/CG.h @@ -0,0 +1,118 @@ +#ifndef _CG_H +#define _CG_H + +#include +#include +#include +#include + +namespace omega { + +class CodeGen; + +struct CG_result { + CodeGen *codegen_; + BoolSet<> active_; + + CG_result() { codegen_ = NULL; } + virtual ~CG_result() { /* not responsible for codegen_ */ } + + virtual CG_result *recompute(const BoolSet<> &parent_active, const Relation &known, const Relation &restriction) = 0; + virtual int populateDepth() = 0; + virtual std::pair liftOverhead(int depth, bool propagate_up) = 0; + virtual Relation hoistGuard() = 0; + virtual void removeGuard(const Relation &guard) = 0; + virtual CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector &stmts, const std::vector > &assigned_on_the_fly) const = 0; + CG_outputRepr *printRepr(CG_outputBuilder *ocg, const std::vector &stmts) const; + std::string printString() const; + int num_level() const; + virtual CG_result *clone() const = 0; + virtual void dump(int indent) const {} + void dump() { dump(0); } +}; + + +struct CG_split: public CG_result { + std::vector restrictions_; + std::vector clauses_; + + CG_split(CodeGen *codegen, const BoolSet<> &active, const std::vector &restrictions, const std::vector &clauses) { + codegen_ = codegen; + active_ = active; + restrictions_ = restrictions; + clauses_ = clauses; + } + ~CG_split() { + for (int i = 0; i < clauses_.size(); i++) + delete clauses_[i]; + } + + CG_result *recompute(const BoolSet<> &parent_active, const Relation &known, const Relation &restriction); + int populateDepth(); + std::pair liftOverhead(int depth, bool propagate_up); + Relation hoistGuard(); + void removeGuard(const Relation &guard); + CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector &stmts, const std::vector > &assigned_on_the_fly) const; + CG_result *clone() const; + void dump(int indent) const; + +private: + std::vector findNextLevel() const; +}; + + +struct CG_loop: public CG_result { + int level_; + CG_result *body_; + + Relation known_; + Relation restriction_; + Relation bounds_; + Relation guard_; + bool needLoop_; + int depth_; + + CG_loop(CodeGen *codegen, const BoolSet<> &active, int level, CG_result *body) { + codegen_ = codegen; + active_ = active; + level_ = level; + body_ = body; + } + ~CG_loop() { delete body_; } + + CG_result *recompute(const BoolSet<> &parent_active, const Relation &known, const Relation &restriction); + int populateDepth(); + std::pair liftOverhead(int depth, bool propagate_up); + Relation hoistGuard(); + void removeGuard(const Relation &guard); + CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector &stmts, const std::vector > &assigned_on_the_fly) const; + CG_outputRepr *printRepr(bool do_print_guard, int indent, CG_outputBuilder *ocg, const std::vector &stmts, const std::vector > &assigned_on_the_fly) const; + CG_result *clone() const; + void dump(int indent) const; +}; + + + +struct CG_leaf: public CG_result { + Relation known_; + std::map guards_; + + CG_leaf(CodeGen *codegen, const BoolSet<> &active) { + codegen_ = codegen; + active_ = active; + } + ~CG_leaf() {} + + CG_result *recompute(const BoolSet<> &parent_active, const Relation &known, const Relation &restriction); + int populateDepth() { return 0; } + std::pair liftOverhead(int depth, bool propagate_up); + Relation hoistGuard(); + void removeGuard(const Relation &guard); + CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector &stmts, const std::vector > &assigned_on_the_fly) const; + CG_result *clone() const; + void dump(int indent) const; +}; + +} + +#endif diff --git a/omega/code_gen/include/code_gen/CG_outputBuilder.h b/omega/code_gen/include/code_gen/CG_outputBuilder.h new file mode 100644 index 0000000..2203235 --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_outputBuilder.h @@ -0,0 +1,177 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + abstract base class of comiler IR code builder + + Notes: + All "CG_outputRepr *" parameters are consumed inside the the function + unless explicitly stated otherwise, i.e., not valid after the call. + Parameter "indent" normally not used except it is used in unstructured + string output for correct indentation. + + History: + 04/17/96 created - Lei Zhou + 05/02/08 clarify integer floor/mod/ceil definitions, -chen + 05/31/08 use virtual clone to implement CreateCopy, -chun + 08/05/10 clarify NULL parameter allowance, -chun +*****************************************************************************/ + +#ifndef _CG_OUTPUTBUILDER_H +#define _CG_OUTPUTBUILDER_H + +#include + +#include +#include + +namespace omega { + +class CG_outputBuilder { +public: + CG_outputBuilder() {} + virtual ~CG_outputBuilder() {} + + //--------------------------------------------------------------------------- + // substitute variables in stmt + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, + const std::vector &vars, + std::vector &subs) const = 0; + + //--------------------------------------------------------------------------- + // assignment stmt generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateAssignment(int indent, CG_outputRepr *lhs, + CG_outputRepr *rhs) const = 0; + + //--------------------------------------------------------------------------- + // function invocation generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateInvoke(const std::string &funcName, + std::vector &argList) const = 0; + + //--------------------------------------------------------------------------- + // comment generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateComment(int indent, + const std::string &commentText) const = 0; + + //--------------------------------------------------------------------------- + // Attribute generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr* CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const = 0; + //--------------------------------------------------------------------------- + // Pragma Attribute + // -------------------------------------------------------------------------- + virtual CG_outputRepr* CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const = 0; + + //--------------------------------------------------------------------------- + // Prefetch Attribute + //--------------------------------------------------------------------------- + virtual CG_outputRepr* CreatePrefetchAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &arrName, int hint) const = 0; + + //--------------------------------------------------------------------------- + // generate if stmt, true/false stmt can be NULL but not the condition + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateIf(int indent, CG_outputRepr *guardCondition, + CG_outputRepr *true_stmtList, + CG_outputRepr *false_stmtList) const = 0; + + //--------------------------------------------------------------------------- + // generate loop inductive variable (loop control structure) + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, + CG_outputRepr *upper, + CG_outputRepr *step) const = 0; + + //--------------------------------------------------------------------------- + // generate loop stmt from loop control and loop body, NULL parameter allowed + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateLoop(int indent, CG_outputRepr *control, + CG_outputRepr *stmtList) const = 0; + + //--------------------------------------------------------------------------- + // copy operation, NULL parameter allowed. this function makes pointer + // handling uniform regardless NULL status + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateCopy(CG_outputRepr *original) const { + if (original == NULL) + return NULL; + else + return original->clone(); + } + + //--------------------------------------------------------------------------- + // basic integer number creation + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateInt(int num) const = 0; + virtual bool isInteger(CG_outputRepr *op) const = 0; + + + //--------------------------------------------------------------------------- + // basic identity/variable creation + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateIdent(const std::string &varName) const = 0; + + //--------------------------------------------------------------------------- + // binary arithmetic operations, NULL parameter means 0, + // Note: + // integer division truncation method undefined, only use when lop is known + // to be multiple of rop, otherwise use integer floor instead + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreatePlus(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + virtual CG_outputRepr *CreateMinus(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + virtual CG_outputRepr *CreateTimes(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + virtual CG_outputRepr *CreateDivide(CG_outputRepr *lop, CG_outputRepr *rop) const { + return CreateIntegerFloor(lop, rop); + } + + //--------------------------------------------------------------------------- + // integer arithmetic functions, NULL parameter means 0, second parameter + // must be postive (i.e. b > 0 below), otherwise function undefined + // Note: + // ceil(a, b) = -floor(-a, b) or floor(a+b-1, b) or floor(a-1, b)+1 + // mod(a, b) = a-b*floor(a, b) + // where result must lie in range [0,b) + // floor(a, b) = a/b if a >= 0 + // (a-b+1)/b if a < 0 + // where native '/' operator behaves as 5/2 = 2, (-5)/2 = -2 + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateIntegerFloor(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + virtual CG_outputRepr *CreateIntegerMod(CG_outputRepr *lop, CG_outputRepr *rop) const { + CG_outputRepr *lop2 = CreateCopy(lop); + CG_outputRepr *rop2 = CreateCopy(rop); + return CreateMinus(lop2, CreateTimes(rop2, CreateIntegerFloor(lop, rop))); + } + virtual CG_outputRepr *CreateIntegerCeil(CG_outputRepr *lop, CG_outputRepr *rop) const { + return CreateMinus(NULL, CreateIntegerFloor(CreateMinus(NULL, lop), rop)); + } + + //--------------------------------------------------------------------------- + // binary logical operation, NULL parameter means TRUE + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + + //--------------------------------------------------------------------------- + // binary condition operations + //--------------------------------------------------------------------------- + virtual CG_outputRepr *CreateGE(CG_outputRepr *lop, CG_outputRepr *rop) const { + return CreateLE(rop, lop); + } + virtual CG_outputRepr *CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + virtual CG_outputRepr *CreateEQ(CG_outputRepr *lop, CG_outputRepr *rop) const = 0; + + //--------------------------------------------------------------------------- + // join stmts together, NULL parameter allowed + //--------------------------------------------------------------------------- + virtual CG_outputRepr *StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const = 0; +}; + +} + +#endif diff --git a/omega/code_gen/include/code_gen/CG_outputRepr.h b/omega/code_gen/include/code_gen/CG_outputRepr.h new file mode 100644 index 0000000..92f3d9f --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_outputRepr.h @@ -0,0 +1,31 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + abstract base class of compiler IR code wrapper + + Notes: + + History: + 04/17/96 - Lei Zhou - created +*****************************************************************************/ + +#ifndef _CG_OUTPUTREPR_H +#define _CG_OUTPUTREPR_H + +namespace omega { + +class CG_outputRepr { +public: + CG_outputRepr() {} + virtual ~CG_outputRepr() { /* shallow delete */ } + virtual CG_outputRepr *clone() const = 0; + virtual void clear() { /* delete actual IR code wrapped inside */ } + virtual void dump() const {} +}; + +} + +#endif diff --git a/omega/code_gen/include/code_gen/CG_roseBuilder.h b/omega/code_gen/include/code_gen/CG_roseBuilder.h new file mode 100644 index 0000000..93b708e --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_roseBuilder.h @@ -0,0 +1,164 @@ +#ifndef CG_roseBuilder_h +#define CG_roseBuilder_h + +#include +#include +#include +#include +#include + +namespace omega { + +class CG_roseBuilder : public CG_outputBuilder { +public: + CG_roseBuilder(int isFortran, SgGlobal* global, SgGlobal* global_scope, SgSymbolTable* symtab1, SgSymbolTable* symtab2, SgNode* root); + ~CG_roseBuilder(); + + //--------------------------------------------------------------------------- + // place holder generation + //--------------------------------------------------------------------------- + // CG_outputRepr* CreatePlaceHolder(int indent, CG_outputRepr *stmt, + // Tuple &funcList, + // Tuple &loop_vars) const; + + + //--------------------------------------------------------------------------- + // substitute variables in stmt + //--------------------------------------------------------------------------- + + + + CG_outputRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, + const std::vector &vars, + std::vector &subs) const; + + + + //--------------------------------------------------------------------------- + // assignment generation + //--------------------------------------------------------------------------- + CG_outputRepr* CreateAssignment(int indent, CG_outputRepr* lhs, + CG_outputRepr* rhs) const; + + //--------------------------------------------------------------------------- + // function invocation generation + //--------------------------------------------------------------------------- + CG_outputRepr* CreateInvoke(const std::string &funcName, + std::vector &argList) const; + + //--------------------------------------------------------------------------- + // comment generation + //--------------------------------------------------------------------------- + CG_outputRepr* CreateComment(int indent, const std::string &commentText) const; + //--------------------------------------------------------------------------- + // Attribute generation + //--------------------------------------------------------------------------- + CG_outputRepr* CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const; + //--------------------------------------------------------------------------- + // Pragma Attribute + //--------------------------------------------------------------------------- + CG_outputRepr* CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, + const std::string &pragmaText) const; + + //--------------------------------------------------------------------------- + // Prefetch Attribute + //--------------------------------------------------------------------------- + CG_outputRepr* CreatePrefetchAttribute(CG_outputRepr *scopeStmt, int looplevel, + const std::string &arrName, int hint) const; + + //--------------------------------------------------------------------------- + // if stmt gen operations + //--------------------------------------------------------------------------- + CG_outputRepr* CreateIf(int indent, CG_outputRepr* guardCondition, + CG_outputRepr* true_stmtList, CG_outputRepr* false_stmtList) const; + + //--------------------------------------------------------------------------- + // inductive variable generation, to be used in CreateLoop as control + //--------------------------------------------------------------------------- + CG_outputRepr* CreateInductive(CG_outputRepr* index, + CG_outputRepr* lower, + CG_outputRepr* upper, + CG_outputRepr* step) const; + + //--------------------------------------------------------------------------- + // loop stmt generation + //--------------------------------------------------------------------------- + CG_outputRepr* CreateLoop(int indent, CG_outputRepr* control, + CG_outputRepr* stmtList) const; + + //--------------------------------------------------------------------------- + // basic operations + //--------------------------------------------------------------------------- + CG_outputRepr* CreateInt(int num ) const; + bool isInteger(CG_outputRepr *op) const; + CG_outputRepr* CreateIdent(const std::string &varName) const; + + //--------------------------------------------------------------------------- + // binary arithmetic operations + //--------------------------------------------------------------------------- + CG_outputRepr* CreatePlus(CG_outputRepr* lop, CG_outputRepr* rop) const; + CG_outputRepr* CreateMinus(CG_outputRepr* lop, CG_outputRepr* rop) const; + CG_outputRepr* CreateTimes(CG_outputRepr* lop, CG_outputRepr* rop) const; + CG_outputRepr* CreateIntegerFloor(CG_outputRepr* lop, CG_outputRepr* rop) const; + CG_outputRepr* CreateIntegerMod(CG_outputRepr* lop, CG_outputRepr* rop) const; + + //--------------------------------------------------------------------------- + // binary logical operations + //--------------------------------------------------------------------------- + CG_outputRepr* CreateAnd(CG_outputRepr* lop, CG_outputRepr* rop) const; + + //--------------------------------------------------------------------------- + // binary relational operations + //--------------------------------------------------------------------------- + // CG_outputRepr* CreateGE(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateLE(CG_outputRepr* lop, CG_outputRepr* rop) const; + CG_outputRepr* CreateEQ(CG_outputRepr* lop, CG_outputRepr* rop) const; + + //--------------------------------------------------------------------------- + // stmt list gen operations + //--------------------------------------------------------------------------- + // CG_outputRepr* + // CreateStmtList(CG_outputRepr *singleton = NULL) const; + // CG_outputRepr* + // StmtListInsertLast(CG_outputRepr* list, CG_outputRepr* node) const; + CG_outputRepr* + StmtListAppend(CG_outputRepr* list1, CG_outputRepr* list2) const; + + //CG_outputRepr* CreateDim3(const char* varName, int arg1, int arg2) const; + CG_outputRepr* CreateDim3(const char* varName, CG_outputRepr* arg1, CG_outputRepr* arg2, CG_outputRepr* arg3 = NULL) const; + + // Manu:: added for fortran support + bool isInputFortran() const; + + //--------------------------------------------------------------------------- + // kernel generation + //--------------------------------------------------------------------------- + // CG_outputRepr* CreateKernel(immed_list* iml) const; + + //--------------------------------------------------------------------------- + // Add a modifier to a type (for things like __global__) + //--------------------------------------------------------------------------- + //type_node* ModifyType(type_node* base, const char* modifier) const; + + +private: + SgSymbolTable *symtab_; + SgSymbolTable *symtab2_; + SgNode* root_; + SgGlobal* global_; + SgGlobal* global_scope; + int isFortran; // Manu:: added for fortran support +}; + +extern char *k_ocg_comment; + //bool substitute(SgExpression *in, SgVariableSymbol *sym, SgExpression *expr, SgNode* root, SgExpression* parent); + //bool substitute(SgStatement *tn, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab); +std::vectorsubstitute(SgNode *tnl, const SgVariableSymbol *sym, SgExpression *expr,SgNode* root) ; + + + + +} // namespace + +#endif diff --git a/omega/code_gen/include/code_gen/CG_roseRepr.h b/omega/code_gen/include/code_gen/CG_roseRepr.h new file mode 100644 index 0000000..4861db7 --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_roseRepr.h @@ -0,0 +1,47 @@ +#ifndef CG_roseRepr_h +#define CG_roseRepr_h + +#include +#include "rose.h" + +namespace omega { + +class CG_roseRepr : public CG_outputRepr { + friend class CG_roseBuilder; +public: + CG_roseRepr(); + CG_roseRepr(SgNode *tnl); + CG_roseRepr(SgExpression *exp); + CG_roseRepr(SgStatementPtrList* stmtlist); + + ~CG_roseRepr(); + CG_outputRepr *clone() const; + void clear(); + + SgNode* GetCode() const; + SgStatementPtrList* GetList() const; + SgExpression *GetExpression() const; + + + + + //--------------------------------------------------------------------------- + // Dump operations + //--------------------------------------------------------------------------- + void Dump() const; + //void DumpToFile(FILE *fp = stderr) const; +private: + // only one of _tnl and _op would be active at any time, depending on + // whether it is building a statement list or an expression tree + SgNode *tnl_; + SgExpression *op_; + SgStatementPtrList *list_; + void DumpFileHelper(SgNode* node, FILE* fp) const; + //operand op_; +}; + + + +} // namespace + +#endif diff --git a/omega/code_gen/include/code_gen/CG_stringBuilder.h b/omega/code_gen/include/code_gen/CG_stringBuilder.h new file mode 100644 index 0000000..09d3503 --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_stringBuilder.h @@ -0,0 +1,44 @@ +#ifndef _CG_STRINGBUILDER_H +#define _CG_STRINGBUILDER_H + +#include +#include + +namespace omega { + +class CG_stringBuilder: public CG_outputBuilder { +public: + CG_stringBuilder() {} + ~CG_stringBuilder() {} + bool isInteger(CG_outputRepr *op) const; + CG_stringRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, const std::vector &vars, std::vector &subs) const; + CG_stringRepr *CreateAssignment(int indent, CG_outputRepr *lhs, CG_outputRepr *rhs) const; + CG_stringRepr *CreateInvoke(const std::string &funcName, std::vector &argList) const; + CG_stringRepr *CreateComment(int indent, const std::string &commentText) const; + CG_stringRepr* CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const; + CG_outputRepr *CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const; + CG_outputRepr *CreatePrefetchAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &arrName, int hint) const; + CG_stringRepr *CreateIf(int indent, CG_outputRepr *guardCondition, CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const; + CG_stringRepr *CreateInductive(CG_outputRepr *index, CG_outputRepr *lower, CG_outputRepr *upper, CG_outputRepr *step) const; + CG_stringRepr *CreateLoop(int indent, CG_outputRepr *control, CG_outputRepr *stmtList) const; + CG_stringRepr *CreateInt(int num) const; + CG_stringRepr *CreateIdent(const std::string &varName) const; + CG_stringRepr *CreatePlus(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateMinus(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateTimes(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateDivide(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateIntegerFloor(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateIntegerMod(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateIntegerCeil(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateGE(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *CreateEQ(CG_outputRepr *lop, CG_outputRepr *rop) const; + CG_stringRepr *StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const; +}; + + +} + +#endif diff --git a/omega/code_gen/include/code_gen/CG_stringRepr.h b/omega/code_gen/include/code_gen/CG_stringRepr.h new file mode 100644 index 0000000..a6df85d --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_stringRepr.h @@ -0,0 +1,43 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + pseudo string code wrapper + + Notes: + + History: + 04/17/96 - Lei Zhou - created +*****************************************************************************/ + +#ifndef _CG_STRINGREPR_H +#define _CG_STRINGREPR_H + +#include +#include +#include + +namespace omega { + +class CG_stringRepr: public CG_outputRepr { +private: + std::string s_; + +public: + CG_stringRepr() {} + CG_stringRepr(const std::string &s) { s_ = s; } + ~CG_stringRepr() {} + CG_outputRepr *clone() const { return new CG_stringRepr(s_); } + void dump() const { std::cout << s_ << std::endl; } + + //--------------------------------------------------------------------------- + // basic operation + //--------------------------------------------------------------------------- + std::string GetString() const { return s_; } +}; + +} + +#endif diff --git a/omega/code_gen/include/code_gen/CG_suifBuilder.h b/omega/code_gen/include/code_gen/CG_suifBuilder.h new file mode 100644 index 0000000..9f57e3d --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_suifBuilder.h @@ -0,0 +1,88 @@ +#ifndef CG_suifBuilder_h +#define CG_suifBuilder_h + +#include +#include +#include +#include + +namespace omega { + + +class CG_suifBuilder: public CG_outputBuilder { +public: + //CG_suifBuilder(proc_symtab *symtab) {symtab_ = symtab;} + CG_suifBuilder(proc_symtab *symtab); + //protonu--initializing code_gen stuff for cuda + //this looks like a flaw in my design + //end--protonu + ~CG_suifBuilder() {} + + CG_outputRepr* CreatePlaceHolder(int indent, CG_outputRepr *stmt, + Tuple &funcList, + Tuple &loop_vars) const; + CG_outputRepr* CreateAssignment(int indent, CG_outputRepr* lhs, + CG_outputRepr* rhs) const; + CG_outputRepr* CreateInvoke(const std::string &fname, + Tuple &argList) const; + CG_outputRepr* CreateComment(int indent, const std::string &commentText) const; + CG_outputRepr* CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const; + + CG_outputRepr* CreateIf(int indent, CG_outputRepr* guardCondition, + CG_outputRepr* true_stmtList, CG_outputRepr* false_stmtList) const; + CG_outputRepr* CreateInductive(CG_outputRepr* index, + CG_outputRepr* lower, + CG_outputRepr* upper, + CG_outputRepr* step) const; + CG_outputRepr* CreateLoop(int indent, CG_outputRepr* control, + CG_outputRepr* stmtList) const; + CG_outputRepr* CreateInt(int) const; + CG_outputRepr* CreateIdent(const std::string &idStr) const; + CG_outputRepr* CreatePlus(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateMinus(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateTimes(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateIntegerDivide(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateIntegerMod(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateAnd(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateGE(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateLE(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* CreateEQ(CG_outputRepr*, CG_outputRepr*) const; + CG_outputRepr* StmtListAppend(CG_outputRepr* list1, CG_outputRepr* list2) const; + //--------------------------------------------------------------------------- + // pragma generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr* CreatePragma(int indent, const std::string &pragmaText) const; + + //--------------------------------------------------------------------------- + // dim3 generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr* CreateDim3(immed varName, immed arg1, immed arg2) const; + virtual CG_outputRepr* CreateDim3(immed varName, immed arg1, immed arg2, immed arg3) const; + + + //--------------------------------------------------------------------------- + // kernel generation + //--------------------------------------------------------------------------- + virtual CG_outputRepr* CreateKernel(immed_list* iml) const; + + //--------------------------------------------------------------------------- + // Add a modifier to a type (for things like __global__) + //--------------------------------------------------------------------------- + type_node* ModifyType(type_node* base, const char* modifier) const; +private: + proc_symtab *symtab_; +}; + +extern char *k_ocg_comment; + +bool substitute(instruction *in, var_sym *sym, operand expr, + base_symtab *st=NULL); +bool substitute(tree_node *tn, var_sym *sym, operand expr, + base_symtab *st=NULL); +bool substitute(tree_node_list *tnl, var_sym *sym, operand expr, + base_symtab *st = NULL); + +} + +#endif diff --git a/omega/code_gen/include/code_gen/CG_suifRepr.h b/omega/code_gen/include/code_gen/CG_suifRepr.h new file mode 100644 index 0000000..ce7c6cd --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_suifRepr.h @@ -0,0 +1,36 @@ +#ifndef CG_suifRepr_h +#define CG_suifRepr_h + +#include +#include + +namespace omega { + +class CG_suifRepr : public CG_outputRepr { + friend class CG_suifBuilder; +public: + CG_suifRepr(); + CG_suifRepr(tree_node_list *tnl); + CG_suifRepr(operand op); + virtual ~CG_suifRepr(); + virtual CG_outputRepr *clone(); + virtual void clear(); + + tree_node_list* GetCode() const; + operand GetExpression() const; + + //--------------------------------------------------------------------------- + // Dump operations + //--------------------------------------------------------------------------- + virtual void Dump() const; + virtual void DumpToFile(FILE *fp = stderr) const; +private: + // only one of _tnl and _op would be active at any time, depending on + // whether it is building a statement list or an expression tree + tree_node_list *tnl_; + operand op_; +}; + +} // namespace + +#endif diff --git a/omega/code_gen/include/code_gen/CG_utils.h b/omega/code_gen/include/code_gen/CG_utils.h new file mode 100755 index 0000000..9e44cb1 --- /dev/null +++ b/omega/code_gen/include/code_gen/CG_utils.h @@ -0,0 +1,45 @@ +#ifndef _CG_UTILS_H +#define _CG_UTILS_H + +#include +#include +#include +#include +#include +#include + +namespace omega { + +class CG_loop; + +CG_outputRepr *output_inequality_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const Relation &R, const std::vector > &assigned_on_the_fly, std::set excluded_floor_vars = std::set()); +CG_outputRepr *output_substitution_repr(CG_outputBuilder *ocg, const EQ_Handle &equality, Variable_ID v, bool apply_v_coef, const Relation &R, const std::vector > &assigned_on_the_fly); +CG_outputRepr *output_upper_bound_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const Relation &R, const std::vector > &assigned_on_the_fly); +CG_outputRepr *output_lower_bound_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const EQ_Handle &stride_eq, Variable_ID wc, const Relation &R, const Relation &known, const std::vector > &assigned_on_the_fly); + +CG_outputRepr *output_ident(CG_outputBuilder *ocg, const Relation &R, Variable_ID v, const std::vector > &assigned_on_the_fly); +std::pair > output_assignment(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector > &assigned_on_the_fly); +CG_outputRepr *output_loop(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector > &assigned_on_the_fly); +CG_outputRepr *output_guard(CG_outputBuilder *ocg, const Relation &R, const std::vector > &assigned_on_the_fly); +std::vector output_substitutions(CG_outputBuilder *ocg, const Relation &R, const std::vector > &assigned_on_the_fly); + +bool bound_must_hit_stride(const GEQ_Handle &inequality, Variable_ID v, const EQ_Handle &stride_eq, Variable_ID wc, const Relation &bounds, const Relation &known); +std::pair find_simplest_assignment(const Relation &R, Variable_ID v, const std::vector > &assigned_on_the_fly = std::vector >()); +std::pair find_floor_definition(const Relation &R, Variable_ID v, std::set excluded_floor_vars = std::set()); +std::pair find_simplest_stride(const Relation &R, Variable_ID v); +Variable_ID replicate_floor_definition(const Relation &R, const Variable_ID floor_var, Relation &r, F_Exists *f_exists, F_And *f_root, std::map &exists_mapping); + +Relation pick_one_guard(const Relation &R, int level = 0); +CG_outputRepr *leaf_print_repr(BoolSet<> active, const std::map &guards, + CG_outputRepr *guard_repr, const Relation &known, + int indent, CG_outputBuilder *ocg, const std::vector &remap, + const std::vector &xforms, const std::vector &stmts, + const std::vector > &assigned_on_the_fly); +CG_outputRepr *loop_print_repr(const std::vector &loops, int start, int end, + const Relation &guard, CG_outputRepr *guard_repr, + int indent, CG_outputBuilder *ocg, const std::vector &stmts, + const std::vector > &assigned_on_the_fly); + +} + +#endif diff --git a/omega/code_gen/include/code_gen/code_gen.h b/omega/code_gen/include/code_gen/code_gen.h new file mode 100644 index 0000000..abfab7c --- /dev/null +++ b/omega/code_gen/include/code_gen/code_gen.h @@ -0,0 +1,47 @@ +#if !defined(Already_Included_code_gen) +#define Already_Included_code_gen + +#include +#include +#include +#include +#include + +namespace omega { + +typedef Tuple IntTuple; +typedef Tuple SetTuple; +typedef Tuple SetTupleTuple; +typedef Tuple RelTuple; +typedef Tuple RelTupleTuple; + +CG_outputRepr *MMGenerateCode(CG_outputBuilder* ocg, + Tuple &T, Tuple &old_IS, + const Tuple &stmt_content, + Relation &known, int effort=1); +std::string MMGenerateCode(Tuple &T, Tuple &old_IS, Relation &known, + int effort=1); + +//protonu-adding a new variant to keep Gabe's code happy +CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, + const Tuple &stmt_content, Relation &known, + Tuple< IntTuple >& smtNonSplitLevels_, + std::vector< std::pair > syncs_, + const Tuple< Tuple >& loopIdxNames_, + int effort=1); +//end-protonu + +struct Polyhedra { + int last_level; + Tuple transformations; + Relation known; + + Tuple remap; // after initial iteration space's disjoint set splitting, the new statement number maps to old statement number + Tuple > projected_nIS; + + Polyhedra(const Tuple &T, const Tuple &old_IS, const Relation &known = Relation::Null()); + ~Polyhedra() {} +}; + +} +#endif diff --git a/omega/code_gen/include/code_gen/codegen.h b/omega/code_gen/include/code_gen/codegen.h new file mode 100755 index 0000000..469653d --- /dev/null +++ b/omega/code_gen/include/code_gen/codegen.h @@ -0,0 +1,44 @@ +#ifndef _CODEGEN_H +#define _CODEGEN_H + +#include +#include +#include +#include +#include + +namespace omega { + +class CodeGen { +public: + static const std::string loop_var_name_prefix; + static const int var_substitution_threshold; + +protected: + std::vector > projected_IS_; // projected_IS_[level-1][new stmt#] + std::vector xforms_; // transformations[original stmt#] + Relation known_; // no need to generate code for constraints satisfied in known + std::vector remap_; // map new stmt# to original stmt# + +public: + CodeGen(const std::vector &xforms, const std::vector &IS, const Relation &known = Relation::Null(), + std::vector< std::vector > smtNonSplitLevels_ = std::vector< std::vector >(), + std::vector< std::vector > loopIdxNames_ = std::vector< std::vector >(), + std::vector< std::pair > syncs_ = std::vector< std::pair >() + ); + ~CodeGen() {} + + CG_result *buildAST(int effort = 1); + int num_level() const { return projected_IS_.size(); } + +private: + CG_result *buildAST(int level, const BoolSet<> &active, bool split_on_const, const Relation &restriction); + + friend class CG_result; + friend class CG_split; + friend class CG_loop; + friend class CG_leaf; +}; + +} +#endif diff --git a/omega/code_gen/include/code_gen/codegen_error.h b/omega/code_gen/include/code_gen/codegen_error.h new file mode 100755 index 0000000..06ecc2b --- /dev/null +++ b/omega/code_gen/include/code_gen/codegen_error.h @@ -0,0 +1,15 @@ +#ifndef _CODEGEN_ERROR_H +#define _CODEGEN_ERROR_H + +#include + +namespace omega { + +struct codegen_error: public std::runtime_error { + codegen_error(const std::string &msg): std::runtime_error("codegen error: " + msg) {} +}; + + +} +#endif + diff --git a/omega/code_gen/include/code_gen/cscope.out b/omega/code_gen/include/code_gen/cscope.out new file mode 100644 index 0000000..23b9ff6 --- /dev/null +++ b/omega/code_gen/include/code_gen/cscope.out @@ -0,0 +1,42592 @@ +cscope 15 $HOME/chill-latest/omega/code_gen/include/code_gen 0000237072 + @CG.h + +1 #i! +defed +( +A̗dy_uded_cg +) + +2  + #A̗dy_uded_cg + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +7  + ~ + +8  + ~ + +10 +mea + + gomega + { + +12  + gTue +<> + tITue +; + +13  + gTue +< + tRi +> + tSTue +; + +14  + gTue +< + tSTue +> + tSTueTue +; + +15  + gTue +< + tRi +> + tRTue +; + +17 as + cCG_su + { + +18 + gpublic +: + +19 +Tue +<> +isAive +; + +20  + gv +; + +21 +Ri + + griis +; + +22 +Ri + + gknown +; + +24 + gpublic +: + +25 +CG_su +() {} + +26 +vtu + ~ +CG_su +() {} + +28 +vtu + +CG_su + * +e +() = 0; + +29 +vtu +  +dth +() = 0; + +30 +vtu + +bo + +isNu +({  + gl +;}; + +31 +vtu + +CG_su + * +liOvhd +( +dth +) = 0; + +32 +vtu + +Ri + +fdOvhd +( +liTo +) = 0; + +33 +vtu + +CG_su + * +f_fe_bounds +() = 0; + +34 +vtu + +Ri + +hoiGud +() = 0; + +35 +vtu +  +moveGud +() = 0; + +36 +vtu + +CG_su + * +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +) = 0; + +38 +vtu + +CG_ouutRr + * +tRr +( +CG_ouutBud +* +ocg +,  +dt +, cڡ +d +:: +ve + & +assigd__the_y +) = 0; + +39 +vtu + + gd +:: +rg + +tSuu +( +dt +) = 0; + +40 +vtu + + gd +:: +rg + +t +( +dt +); + +44 as + cCG_nu + : +public + +CG_su + { + +45 +public +: + +46 +CG_su + * +e +() { + +47  +w + +CG_nu +; + +49 + gd +:: +rg + +tSuu +() { + +52 +CG_ouutRr + * +tRr +( +CG_ouutBud +*, , cڡ +d +:: +ve + &) + +53 {  ( +CG_ouutRr + *)0; }; + +55  +dth +() {  0; } + +56 +bo + +isNu +({  + gue +;}; + +57 +CG_su + * +compu +(cڡ +Ri + &, const Relation &) { + +58  + gthis +; + +60 +CG_su + * +liOvhd +() { + +61  + gthis +; + +63 +Ri + +fdOvhd +() { + +64  + gRi +:: +True +(1); + +66 +CG_su + * +f_fe_bounds +({  + gthis +; }; + +67 +Ri + +hoiGud +({  + gRi +:: +True +(1); } + +68  +moveGud +() { } + +73 as + cCG_l + : +public + +CG_su + { + +74 +public +: + +75 +CG_su + * +ueCu +,* + glCu +; + +76 +Ri + + gcdi +; + +77 +Ri + + ggud +; + +79 + gpublic +: + +80 +CG_l +( +ITue + & +aive +,  +lvl +, cڡ +Ri + & +cd_ +, +CG_su + * +T +, CG_su * +F +); + +81 ~ +CG_l +({ +de + + gueCu +; d + glCu +; } + +83 +CG_su + * +e +() { + +84 +Ri + + gc + = +cdi +; + +85  +w + +CG_l +( +isAive +, +v +, +c +, + +86 +ueCu +-> +e +(), +lCu +->clone()); + +88  +dth +() + +89 {  +max +( +ueCu +-> +dth +(), +lCu +->depth()); } + +90 + gd +:: +rg + +tSuu +( +dt +); + +91 +CG_ouutRr + * +tRr +( +CG_ouutBud +* +ocg +,  +dt +, cڡ +d +:: +ve + & +assigd__the_y +); + +93 +CG_su + * +liOvhd +( +dth +); + +94 +CG_su + * +f_fe_bounds +(); + +95 +Ri + +fdOvhd +( +liTo +); + +96 +CG_su + * +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +); + +97 +Ri + +hoiGud +(); + +98  +moveGud +({ + ggud + = +Ri +:: +True +( +cdi +. +n_t +()); } + +104 as + cCG_af + : +public + +CG_su + { + +105 +public +: + +106 +STue + +gud +; + +108 + gpublic +: + +109 +CG_af +( +ITue + & +aive +) { + +110 +isAive + = +aive +; + +111 + ggud +. +lo +( +isAive +. +size +()); + +113 ~ +CG_af +() {} + +115 +CG_su + * +e +() { + +116  +w + +CG_af +( +isAive +); + +118 +CG_su + * +liOvhd +() { + +119  + gthis +; + +121 +CG_su + * +f_fe_bounds +() { + +122  + gthis +; + +124 +Ri + +fdOvhd +( +liTo +); + +125 + gd +:: +rg + +tSuu +( +dt +); + +126 +CG_ouutRr + * +tRr +( +CG_ouutBud +* +ocg +,  +dt +, cڡ +d +:: +ve + & +assigd__the_y +); + +127  +dth +() {  0; } + +128 +CG_su + * +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +); + +129 +Ri + +hoiGud +(); + +130  +moveGud +(); + +133 as + cCG_lo + : +public + +CG_su + { + +134 +public +: + +135 +Ri + +bounds +; + +136 +Ri + + ggud +; + +137 +bo + + gedLo +; + +138 +CG_su + * + gbody +; + +140 + gpublic +: + +141 +CG_lo +( +ITue + & +aive +,  +lvl +, +CG_su + * +b +) { + +142 + gisAive + = +aive +; + +143 + gv + = +lvl +; + +144 + gbody + = +b +; + +146 ~ +CG_lo +({ +de + + gbody +; } + +148 +CG_su + * +e +() { + +149  +w + +CG_lo +( +isAive +, +v +, +body +-> +e +()); + +151 +Ri + +fdOvhd +( +liTo +); + +152 +CG_su + * +f_fe_bounds +(); + +153 +CG_su + * +liOvhd +( +dth +); + +154 + gd +:: +rg + +tSuu +( +dt +); + +155 +CG_ouutRr + * +tRr +( +CG_ouutBud +* +ocg +,  +dt +, cڡ +d +:: +ve + & +assigd__the_y +); + +156  +dth +({  ( + gedLo +?1:0)+ +body +->depth(); } + +157 +CG_su + * +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +); + +158 +Ri + +hoiGud +(); + +159  +moveGud +({ + ggud + = +Ri +:: +True +( +bounds +. +n_t +()); } + + @CG_outputBuilder.h + +21 #ide +CG_ouutBud_h + + +22  + #CG_ouutBud_h + + + ) + +24  + ~ + +25  + ~ + +26  + ~ + +28 +mea + + gomega + { + +30 as + cCG_ouutBud + { + +31 + gpublic +: + +32 +CG_ouutBud +() {} + +33 +vtu + ~ +CG_ouutBud +() {} + +38 +vtu + +CG_ouutRr +* +CePHd +( +dt +, CG_ouutR* +mt +, + +39 +Tue +< +CG_ouutRr +*> & +funcLi +, + +40 +Tue +< +d +:: +rg +> & +lo_vs +) const = 0; + +45 +vtu + +CG_ouutRr +* +CeAssignmt +( +dt +, CG_ouutRr* +lhs +, + +46 +CG_ouutRr +* +rhs +) const = 0; + +51 +vtu + +CG_ouutRr +* +CeInvoke +(cڡ +d +:: +rg + & +ame +, + +52 +Tue +< +CG_ouutRr +*> & +gLi +) const = 0; + +57 +vtu + +CG_ouutRr +* +CeCommt +( +dt +, + +58 cڡ +d +:: +rg + & +commtText +) const = 0; + +63 +vtu + +CG_ouutRr +* +CeIf +( +dt +, CG_ouutRr* +gudCdi +, + +64 +CG_ouutRr +* +ue_mtLi +, + +65 +CG_ouutRr +* +l_mtLi +) const = 0; + +70 +vtu + +CG_ouutRr +* +CeInduive +(CG_ouutRr* +dex +, + +71 +CG_ouutRr +* +low +, + +72 +CG_ouutRr +* +u +, + +73 +CG_ouutRr +* + +) const = 0; + +78 +vtu + +CG_ouutRr +* +CeLo +( +dt +, CG_ouutRr* +cڌ +, + +79 +CG_ouutRr +* +mtLi +) const = 0; + +84 +vtu + +CG_ouutRr +* +CeCy +(CG_ouutRr* +ig +) const { + +85 i( + gig + = +NULL +) + +86  +NULL +; + +88  + gig +-> +e +(); + +94 +vtu + +CG_ouutRr +* +CeI +() const = 0; + +95 +vtu + +CG_ouutRr +* +CeIdt +(cڡ +d +:: +rg + & +idS +) const = 0; + +100 +vtu + +CG_ouutRr +* +CePlus +(CG_outputRepr*, CG_outputRepr*) const = 0; + +101 +vtu + +CG_ouutRr +* +CeMus +(CG_outputRepr*, CG_outputRepr*) const = 0; + +102 +vtu + +CG_ouutRr +* +CeTimes +(CG_outputRepr*, CG_outputRepr*) const = 0; + +117 +vtu + +CG_ouutRr +* +CeIegDivide +(CG_outputRepr*, CG_outputRepr*) const = 0; + +118 +vtu + +CG_ouutRr +* +CeIegMod +(CG_ouutR* +l +, CG_ouutR* +r +) const { + +119 +CG_ouutRr + * + gl2 + = +CeCy +( +l +); + +120 +CG_ouutRr + * + gr2 + = +CeCy +( +r +); + +121  +CeMus +( +l2 +, +CeTimes +( +r2 +, +CeIegDivide +( +l +, +r +))); + +123 +vtu + +CG_ouutRr +* +CeIegCe +(CG_ouutRr* +l +, CG_ouutRr* +r +) const { + +124  +CeMus +( +NULL +, +CeIegDivide +(CeMus(NULL, +l +), +r +)); + +130 +vtu + +CG_ouutRr +* +CeAnd +(CG_outputRepr*, CG_outputRepr*) const = 0; + +135 +vtu + +CG_ouutRr +* +CeGE +(CG_outputRepr*, CG_outputRepr*) const = 0; + +136 +vtu + +CG_ouutRr +* +CeLE +(CG_outputRepr*, CG_outputRepr*) const = 0; + +137 +vtu + +CG_ouutRr +* +CeEQ +(CG_outputRepr*, CG_outputRepr*) const = 0; + +142 +vtu + +CG_ouutRr +* +StmtLiAd +(CG_ouutRr* +li1 +, CG_ouutRr* +li2 +) const = 0; + + @CG_outputRepr.h + +16 #ide +CG_ouutRr_h + + +17  + #CG_ouutRr_h + + + ) + +19  + ~ + +20  + ~ + +21  + ~ + +23 +mea + + gomega + { + +25 as + cCG_ouutRr + { + +26 + gpublic +: + +27 +vtu + ~ +CG_ouutRr +() {}; + +28 +vtu + +CG_ouutRr + * +e +() = 0; + +29 +vtu +  +r +() {}; + +34 +vtu +  +Dump +() const = 0; + +35 +vtu +  +DumpToFe +( +FILE + * + + = +dr +) const = 0; + + @CG_stringBuilder.h + +1 #ide +CG_rgBud_h + + +2  + #CG_rgBud_h + + + ) + +4  + ~ + +5  + ~ + +7 +mea + + gomega + { + +9 as + cCG_rgBud +: +public + +CG_ouutBud + { + +10 +public +: + +11 +CG_rgBud +() {} + +12 ~ +CG_rgBud +() {} + +14 +CG_ouutRr +* +CePHd +( +dt +, CG_ouutR* +mt +, + +15 +Tue +< +CG_ouutRr +*> & +funcLi +, + +16 +Tue +< +d +:: +rg +> & +lo_vs +) const; + +18 +CG_ouutRr +* +CeAssignmt +( +dt +, CG_ouutRr* +lhs +, + +19 +CG_ouutRr +* +rhs +) const; + +20 +CG_ouutRr +* +CeInvoke +(cڡ +d +:: +rg + & +ame +, + +21 +Tue +< +CG_ouutRr +*> & +gLi +) const; + +22 +CG_ouutRr +* +CeCommt +( +dt +, cڡ +d +:: +rg + & +commtText +) const; + +23 +CG_ouutRr +* +CeIf +( +dt +, CG_ouutRr* +gudCdi +, + +24 +CG_ouutRr +* +ue_mtLi +, CG_ouutRr* +l_mtLi +) const; + +25 +CG_ouutRr +* +CeInduive +(CG_ouutRr* +dex +, + +26 +CG_ouutRr +* +low +, + +27 +CG_ouutRr +* +u +, + +28 +CG_ouutRr +* + +) const; + +29 +CG_ouutRr +* +CeLo +( +dt +, CG_ouutRr* +cڌ +, + +30 +CG_ouutRr +* +mtLi +) const; + +31 +CG_ouutRr +* +CeI +() const; + +32 +CG_ouutRr +* +CeIdt +(cڡ +d +:: +rg + & +idS +) const; + +33 +CG_ouutRr +* +CePlus +(CG_outputRepr*, CG_outputRepr*) const; + +34 +CG_ouutRr +* +CeMus +(CG_outputRepr*, CG_outputRepr*) const; + +35 +CG_ouutRr +* +CeTimes +(CG_outputRepr*, CG_outputRepr*) const; + +36 +CG_ouutRr +* +CeIegDivide +(CG_outputRepr*, CG_outputRepr*) const; + +37 +CG_ouutRr +* +CeIegMod +(CG_outputRepr*, CG_outputRepr*) const; + +38 +CG_ouutRr +* +CeIegCe +(CG_outputRepr*, CG_outputRepr*) const; + +39 +CG_ouutRr +* +CeAnd +(CG_outputRepr*, CG_outputRepr*) const; + +40 +CG_ouutRr +* +CeGE +(CG_outputRepr*, CG_outputRepr*) const; + +41 +CG_ouutRr +* +CeLE +(CG_outputRepr*, CG_outputRepr*) const; + +42 +CG_ouutRr +* +CeEQ +(CG_outputRepr*, CG_outputRepr*) const; + +43 +CG_ouutRr +* +StmtLiAd +(CG_ouutRr* +li1 +, CG_ouutRr* +li2 +) const; + +46 + gd +:: +rg + +GSg +( +CG_ouutRr +* + +); + +47 + gd +:: +rg + +GIndtSs +( +dt +); + + @CG_stringRepr.h + +1 #ide +CG_rgRr_h + + +2  + #CG_rgRr_h + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +8 +mea + + gomega + { + +10 as + cCG_rgRr + : +public + +CG_ouutRr + { + +11 +public +: + +12 +CG_rgRr +(); + +13 +CG_rgRr +(cڡ +d +:: +rg +& +_s +); + +14 + gvtu + ~ +CG_rgRr +(); + +15 +vtu + +CG_ouutRr + * +e +(); + +20 + gd +:: +rg + +GSg +() const; + +25 +vtu +  +Dump +() const; + +26 +vtu +  +DumpToFe +( +FILE + * + + = +dr +) const; + +27 + give +: + +28 +d +:: +rg + +s +; + + @CG_suifBuilder.h + +1 #ide +CG_suifBud_h + + +2  + #CG_suifBud_h + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +7  + ~ + +9 +mea + + gomega + { + +11 as + cCG_suifBud +: +public + +CG_ouutBud + { + +12 +public +: + +13 +CG_suifBud +( +oc_symb + * +symb +{ +symb_ + = symtab;} + +14 ~ +CG_suifBud +() {} + +16 +CG_ouutRr +* +CePHd +( +dt +, CG_ouutR* +mt +, + +17 +Tue +< +CG_ouutRr +*> & +funcLi +, + +18 +Tue +< +d +:: +rg +> & +lo_vs +) const; + +19 +CG_ouutRr +* +CeAssignmt +( +dt +, CG_ouutRr* +lhs +, + +20 +CG_ouutRr +* +rhs +) const; + +21 +CG_ouutRr +* +CeInvoke +(cڡ +d +:: +rg + & +ame +, + +22 +Tue +< +CG_ouutRr +*> & +gLi +) const; + +23 +CG_ouutRr +* +CeCommt +( +dt +, cڡ +d +:: +rg + & +commtText +) const; + +24 +CG_ouutRr +* +CeIf +( +dt +, CG_ouutRr* +gudCdi +, + +25 +CG_ouutRr +* +ue_mtLi +, CG_ouutRr* +l_mtLi +) const; + +26 +CG_ouutRr +* +CeInduive +(CG_ouutRr* +dex +, + +27 +CG_ouutRr +* +low +, + +28 +CG_ouutRr +* +u +, + +29 +CG_ouutRr +* + +) const; + +30 +CG_ouutRr +* +CeLo +( +dt +, CG_ouutRr* +cڌ +, + +31 +CG_ouutRr +* +mtLi +) const; + +32 +CG_ouutRr +* +CeI +() const; + +33 +CG_ouutRr +* +CeIdt +(cڡ +d +:: +rg + & +idS +) const; + +34 +CG_ouutRr +* +CePlus +(CG_outputRepr*, CG_outputRepr*) const; + +35 +CG_ouutRr +* +CeMus +(CG_outputRepr*, CG_outputRepr*) const; + +36 +CG_ouutRr +* +CeTimes +(CG_outputRepr*, CG_outputRepr*) const; + +37 +CG_ouutRr +* +CeIegDivide +(CG_outputRepr*, CG_outputRepr*) const; + +38 +CG_ouutRr +* +CeIegMod +(CG_outputRepr*, CG_outputRepr*) const; + +39 +CG_ouutRr +* +CeAnd +(CG_outputRepr*, CG_outputRepr*) const; + +40 +CG_ouutRr +* +CeGE +(CG_outputRepr*, CG_outputRepr*) const; + +41 +CG_ouutRr +* +CeLE +(CG_outputRepr*, CG_outputRepr*) const; + +42 +CG_ouutRr +* +CeEQ +(CG_outputRepr*, CG_outputRepr*) const; + +43 +CG_ouutRr +* +StmtLiAd +(CG_ouutRr* +li1 +, CG_ouutRr* +li2 +) const; + +47 +vtu + +CG_ouutRr +* +CePgma +( +dt +, cڡ +d +:: +rg + & +agmaText +) const; + +52 +vtu + +CG_ouutRr +* +CeDim3 +( +immed + +vName +, immed +g1 +, immed +g2 +) const; + +53 +vtu + +CG_ouutRr +* +CeDim3 +( +immed + +vName +, immed +g1 +, immed +g2 +, immed +g3 +) const; + +59 +vtu + +CG_ouutRr +* +CeKl +( +immed_li +* +iml +) const; + +64 +ty_node +* +ModifyTy +y_node* +ba +, cڡ * +modifr +) const; + +65 + give +: + +66 +oc_symb + * +symb_ +; + +69 * +k_ocg_commt +; + +71 +bo + +subu +( +rui + * + +, +v_sym + * +sym +, +ݔd + +ex +, + +72 +ba_symb + * + += +NULL +); + +73 +bo + +subu +( +_node + * + +, +v_sym + * +sym +, +ݔd + +ex +, + +74 +ba_symb + * + += +NULL +); + +75 +bo + +subu +( +_node_li + * +l +, +v_sym + * +sym +, +ݔd + +ex +, + +76 +ba_symb + * + + = +NULL +); + + @CG_suifRepr.h + +1 #ide +CG_suifRr_h + + +2  + #CG_suifRr_h + + + ) + +4  + ~ + +5  + ~ + +7 +mea + + gomega + { + +9 as + cCG_suifRr + : +public + +CG_ouutRr + { + +10 +nd + +ass + +CG_suifBud +; + +11 + gpublic +: + +12 +CG_suifRr +(); + +13 +CG_suifRr +( +_node_li + * +l +); + +14 +CG_suifRr +( +ݔd + + +); + +15 + gvtu + ~ +CG_suifRr +(); + +16 +vtu + +CG_ouutRr + * +e +(); + +17 +vtu +  +r +(); + +19 +_node_li +* +GCode +() const; + +20 +ݔd + +GExessi +() const; + +25 +vtu +  +Dump +() const; + +26 +vtu +  +DumpToFe +( +FILE + * + + = +dr +) const; + +27 + give +: + +30 +_node_li + * +l_ +; + +31 +ݔd + + g_ +; + + @code_gen.h + +1 #i! +defed +( +A̗dy_Inuded_code_g +) + +2  + #A̗dy_Inuded_code_g + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +7  + ~ + +8  + ~ + +10 +mea + + gomega + { + +12  + gTue +<> + tITue +; + +13  + gTue +< + tRi +> + tSTue +; + +14  + gTue +< + tSTue +> + tSTueTue +; + +15  + gTue +< + tRi +> + tRTue +; + +16  + gTue +< + tRTue +> + tRTueTue +; + +18 +CG_ouutRr + * +MMGeCode +( +CG_ouutBud +* +ocg +, + +19 +Tue +< +Ri +> & +T +, Tue & +d_IS +, + +20 cڡ +Tue +< +CG_ouutRr + *> & +mt_cڋ +, + +21 +Ri + & +known +,  +efft +=1); + +22 + gd +:: +rg + +MMGeCode +( +Tue +< +Ri +> & +T +, Tue & +d_IS +, Ri & +known +, + +23  +efft +=1); + +27  + sPyhed + { + +28  + gϡ_v +; + +29 + gTue +< + gRi +> + gsfmis +; + +30 +Ri + + gknown +; + +32 + gTue +<> + gm +; + +33 + gTue + > + gojeed_nIS +; + +35 +Pyhed +(cڡ +Tue +< +Ri +> & +T +, cڡ Tue & +d_IS +, cڡ Ri & +known + = Ri:: +Nu +()); + +36 ~ +Pyhed +() {} + + @output_repr.h + +1 #ide +OUTPUT_REPR_H + + +2  + #OUTPUT_REPR_H + + + ) + +4  + ~ + +5  + ~ + +6  + ~ + +7  + ~ + +8  + ~ + +10 +mea + + gomega + { + +11  +ϡ_v +; + +13 +CG_ouutRr +* +ouutIdt +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +R +, +Vb_ID + +v +, cڡ +d +:: +ve + & +assigd__the_y +); + +14 + gd +:: + +< +CG_ouutRr + *, + gbo +> +ouutAssignmt +( +CG_ouutBud + * +ocg +, cڡ +Ri + & +R_ +, +Vb_ID + +v +, Ri & +fd +, CG_ouutR*& +if_ +, cڡ +d +:: +ve + & +assigd__the_y +); + +15 + gd +:: + +< +CG_ouutRr + *, + gbo +> +ouutBounds +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +bounds +, +Vb_ID + +v +,  +dt +, Ri & +fd +, cڡ +d +:: +ve + & +assigd__the_y +); + +16 + gTue +< + gCG_ouutRr +*> +ouutSubuti +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +R +, cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +); + +17 +CG_ouutRr +* +ouutSmt +( +CG_ouutBud +* +ocg +, CG_ouutR* +mt +,  +dt +, cڡ +Ri + & +mpg +, cڡ Ri & +known +, cڡ +d +:: +ve + & +assigd__the_y +); + +18 +CG_ouutRr +* +ouutGud +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, cڡ +d +:: +ve + & +assigd__the_y +); + +19 +CG_ouutRr +* +ouut_as_gud +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, +Cڡt_Hd + +e +, +bo + +is_equy +, cڡ +d +:: +ve + & +assigd__the_y +); + +20 +CG_ouutRr +* +ouut_EQ_rides +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, cڡ +d +:: +ve + & +assigd__the_y +); + +21 +CG_ouutRr +* +ouut_GEQ_rides +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, cڡ +d +:: +ve + & +assigd__the_y +); + +22 +CG_ouutRr + * +ouutLBasRr +( +CG_ouutBud +* +ocg +, cڡ +GEQ_Hd + & +g +, +Ri + & +bounds +, +Vb_ID + +v +, +cf_t + +ride +, cڡ +EQ_Hd + & +rideEQ +, Ri +known +, cڡ +d +:: +ve + & +assigd__the_y +); + +23 +CG_ouutRr + * +ouutUBasRr +( +CG_ouutBud +* +ocg +, cڡ +GEQ_Hd + & +g +, +Ri + & +bounds +, +Vb_ID + +v +, + +24 +cf_t + , + +25 cڡ +EQ_Hd + & , + +26 cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y + = std::ve( +ϡ_v +, +ic_ +( +NULL +))); + +27 +CG_ouutRr +* +ouutEasyBoundAsRr +( +CG_ouutBud +* +ocg +, +Ri + & +bounds +, cڡ +Cڡt_Hd + & +g +, +Vb_ID + +v +, +bo + +igneWC +,  +g +, cڡ +d +:: +ve + & +assigd__the_y +); + +30 +bo + +boundHsSide +(cڡ +GEQ_Hd + & +g +, +Vb_ID + +v +, cڡ +EQ_Hd + & +rideEQ +, +cf_t + , +Ri + +known +); + +31 +Ri + +ge_comm_ +(cڡ +Tue + & +I +, cڡ Tue<> & +aive +,  +v +, cڡ Ri & +known + = Ri:: +Nu +()); + +32 +bo + +fdFloIquy +( +Ri + & +r +, +Vb_ID + +v +, +GEQ_Hd + & +h +, Vb_ID +exuded +); + +33 +Ri + +oje_to_vs +(Ri +R +,  +ϡ_v +, +bo + +wdrds +); + +34 +bo + +isSimeSide +(cڡ +EQ_Hd + & +g +, +Vb_ID + +v +); + +35  +couSides +( +Cjun + * +c +, +Vb_ID + +v +, +EQ_Hd + & +rideEQ +, +bo + & +sime +); + +36 +bo + +hasBound +( +Ri + +r +,  +v +,  +UB +); + +37 +bo + +fd_y_cڡt +( +s +,  +v +, +Ri + & +kr +,  +dei +, Ri & +S +, bo +ox +); + +38 +bo + +has_nڡride_EQ +( +Ri + +r +,  +v +); + +39 +Ri + +pickOvhd +(Ri +r +,  +liTo +); + +40 +Ri + +mMaxOvhd +(Ri +r +,  +v +); + +41  +max_fs_y +(cڡ +Cڡt_Hd + & +c +); + + @/usr/include/stdio.h + +24 #ide +_STDIO_H + + +26 #i! +defed + +__ed_FILE + && !defed +__ed___FILE + + +27  + #_STDIO_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +32  + #__ed_size_t + + + ) + +33  + #__ed_NULL + + + ) + +34  + ~ + +36  + ~ + +37  + #__ed_FILE + + + ) + +38  + #__ed___FILE + + + ) + +42 #i! +defed + +__FILE_defed + && defed +__ed_FILE + + +45  + g_IO_FILE +; + +47 +__BEGIN_NAMESPACE_STD + + +49  +_IO_FILE + + tFILE +; + +50 + g__END_NAMESPACE_STD + + +51 #i +defed + +__USE_LARGEFILE64 + || defed +__USE_SVID + || defed +__USE_POSIX + \ + +52 || +defed + + g__USE_BSD + || defed + g__USE_ISOC99 + || defed + g__USE_XOPEN + \ + +53 || +defed + +__USE_POSIX2 + + +54 + $__USING_NAMESPACE_STD +( +FILE +) + +57  + #__FILE_defed + 1 + + ) + +59 #unde +__ed_FILE + + +62 #i! +defed + +____FILE_defed + && defed +__ed___FILE + + +65  +_IO_FILE + + t__FILE +; + +67  + #____FILE_defed + 1 + + ) + +69 #unde +__ed___FILE + + +72 #ifdef +_STDIO_H + + +73  + #_STDIO_USES_IOSTREAM + + + ) + +75  + ~ + +77 #ifde +__USE_XOPEN + + +78 #ifde +__GNUC__ + + +79 #ide +_VA_LIST_DEFINED + + +80  +_G_va_li + + tva_li +; + +81  + #_VA_LIST_DEFINED + + + ) + +84  + ~ + +89 +__BEGIN_NAMESPACE_STD + + +90 #ide +__USE_FILE_OFFSET64 + + +91  +_G_os_t + + tos_t +; + +93  +_G_os64_t + + tos_t +; + +95 +__END_NAMESPACE_STD + + +96 #ifde +__USE_LARGEFILE64 + + +97  +_G_os64_t + + tos64_t +; + +101  + #_IOFBF + 0 + + ) + +102  + #_IOLBF + 1 + + ) + +103  + #_IONBF + 2 + + ) + +107 #ide +BUFSIZ + + +108  + #BUFSIZ + +_IO_BUFSIZ + + + ) + +114 #ide +EOF + + +115  + #EOF + (-1) + + ) + +121  + #SEEK_SET + 0 + + ) + +122  + #SEEK_CUR + 1 + + ) + +123  + #SEEK_END + 2 + + ) + +126 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +128  + #P_tmpd + "/tmp" + + ) + +141  + ~ + +145  +_IO_FILE + * +d +; + +146  +_IO_FILE + * +dout +; + +147  +_IO_FILE + * +dr +; + +149  + #d + +d + + + ) + +150  + #dout + +dout + + + ) + +151  + #dr + +dr + + + ) + +153 +__BEGIN_NAMESPACE_STD + + +155  + $move + ( +__cڡ + * +__fame + +__THROW +; + +157  + $me + ( +__cڡ + * +__d +, __cڡ * +__w + +__THROW +; + +158 +__END_NAMESPACE_STD + + +160 #ifde +__USE_ATFILE + + +162  + $mt + ( +__dfd +, +__cڡ + * +__d +,  +__wfd +, + +163 +__cڡ + * +__w + +__THROW +; + +166 +__BEGIN_NAMESPACE_STD + + +171 #ide +__USE_FILE_OFFSET64 + + +172 +FILE + * + $tmpfe + ( +__wur +; + +174 #ifde +__REDIRECT + + +175 +FILE + * + `__REDIRECT + ( +tmpfe +, (), +tmpfe64 + +__wur +; + +177  + #tmpfe + +tmpfe64 + + + ) + +181 #ifde +__USE_LARGEFILE64 + + +182 +FILE + * + $tmpfe64 + ( +__wur +; + +186 * + $tmam + (* +__s + +__THROW + +__wur +; + +187 +__END_NAMESPACE_STD + + +189 #ifde +__USE_MISC + + +192 * + $tmam_r + (* +__s + +__THROW + +__wur +; + +196 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +204 * + $mam + ( +__cڡ + * +__d +, __cڡ * +__pfx +) + +205 +__THROW + +__ibu_mloc__ + +__wur +; + +209 +__BEGIN_NAMESPACE_STD + + +214  + `fo + ( +FILE + * +__am +); + +219  + `fush + ( +FILE + * +__am +); + +220 +__END_NAMESPACE_STD + + +222 #ifde +__USE_MISC + + +229  + `fush_uocked + ( +FILE + * +__am +); + +232 #ifde +__USE_GNU + + +239  + `fol + (); + +243 +__BEGIN_NAMESPACE_STD + + +244 #ide +__USE_FILE_OFFSET64 + + +249 +FILE + * + $fݒ + ( +__cڡ + * +__ri + +__fame +, + +250 +__cڡ + * +__ri + +__modes + +__wur +; + +255 +FILE + * + $eݒ + ( +__cڡ + * +__ri + +__fame +, + +256 +__cڡ + * +__ri + +__modes +, + +257 +FILE + * +__ri + +__am + +__wur +; + +259 #ifde +__REDIRECT + + +260 +FILE + * + `__REDIRECT + ( +fݒ +, ( +__cڡ + * +__ri + +__fame +, + +261 +__cڡ + * +__ri + +__modes +), +fݒ64 +) + +262 +__wur +; + +263 +FILE + * + `__REDIRECT + ( +eݒ +, ( +__cڡ + * +__ri + +__fame +, + +264 +__cڡ + * +__ri + +__modes +, + +265 +FILE + * +__ri + +__am +), +eݒ64 +) + +266 +__wur +; + +268  + #fݒ + +fݒ64 + + + ) + +269  + #eݒ + +eݒ64 + + + ) + +272 +__END_NAMESPACE_STD + + +273 #ifde +__USE_LARGEFILE64 + + +274 +FILE + * + $fݒ64 + ( +__cڡ + * +__ri + +__fame +, + +275 +__cڡ + * +__ri + +__modes + +__wur +; + +276 +FILE + * + $eݒ64 + ( +__cڡ + * +__ri + +__fame +, + +277 +__cڡ + * +__ri + +__modes +, + +278 +FILE + * +__ri + +__am + +__wur +; + +281 #ifdef +__USE_POSIX + + +283 +FILE + * + $fdݒ + ( +__fd +, +__cڡ + * +__modes + +__THROW + +__wur +; + +286 #ifdef +__USE_GNU + + +289 +FILE + * + $fݒcook + (* +__ri + +__magic_cook +, + +290 +__cڡ + * +__ri + +__modes +, + +291 +_IO_cook_io_funis_t + +__io_funcs + +__THROW + +__wur +; + +294 #ifde +__USE_XOPEN2K8 + + +296 +FILE + * + $fmemݒ + (* +__s +, +size_t + +__n +, +__cڡ + * +__modes +) + +297 +__THROW + +__wur +; + +302 +FILE + * + $ݒ_memam + (** +__buoc +, +size_t + * +__sizoc + +__THROW + +__wur +; + +306 +__BEGIN_NAMESPACE_STD + + +309  + $tbuf + ( +FILE + * +__ri + +__am +, *__ri +__buf + +__THROW +; + +313  + $tvbuf + ( +FILE + * +__ri + +__am +, *__ri +__buf +, + +314  +__modes +, +size_t + +__n + +__THROW +; + +315 +__END_NAMESPACE_STD + + +317 #ifdef +__USE_BSD + + +320  + $tbufr + ( +FILE + * +__ri + +__am +, *__ri +__buf +, + +321 +size_t + +__size + +__THROW +; + +324  + $ebuf + ( +FILE + * +__am + +__THROW +; + +328 +__BEGIN_NAMESPACE_STD + + +333  + `rtf + ( +FILE + * +__ri + +__am +, + +334 +__cڡ + * +__ri + +__fm +, ...); + +339  + `tf + ( +__cڡ + * +__ri + +__fm +, ...); + +341  + $rtf + (* +__ri + +__s +, + +342 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +348  + `vrtf + ( +FILE + * +__ri + +__s +, +__cڡ + *__ri +__fm +, + +349 +_G_va_li + +__g +); + +354  + `vtf + ( +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +); + +356  + $vrtf + (* +__ri + +__s +, +__cڡ + *__ri +__fm +, + +357 +_G_va_li + +__g + +__THROW +; + +358 +__END_NAMESPACE_STD + + +360 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +361 +__BEGIN_NAMESPACE_C99 + + +363  + $tf + (* +__ri + +__s +, +size_t + +__maxn +, + +364 +__cڡ + * +__ri + +__fm +, ...) + +365 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +367  + $vtf + (* +__ri + +__s +, +size_t + +__maxn +, + +368 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +369 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +370 +__END_NAMESPACE_C99 + + +373 #ifde +__USE_GNU + + +376  + $vartf + (** +__ri + +__r +, +__cڡ + *__ri +__f +, + +377 +_G_va_li + +__g +) + +378 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 2, 0)) +__wur +; + +379  + $__artf + (** +__ri + +__r +, + +380 +__cڡ + * +__ri + +__fmt +, ...) + +381 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 2, 3)) +__wur +; + +382  + $artf + (** +__ri + +__r +, + +383 +__cڡ + * +__ri + +__fmt +, ...) + +384 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 2, 3)) +__wur +; + +387 #ifde +__USE_XOPEN2K8 + + +394  + $vdtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, + +395 +_G_va_li + +__g +) + +396 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +397  + $dtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, ...) + +398 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +402 +__BEGIN_NAMESPACE_STD + + +407  + $fsnf + ( +FILE + * +__ri + +__am +, + +408 +__cڡ + * +__ri + +__fm +, ... +__wur +; + +413  + $snf + ( +__cڡ + * +__ri + +__fm +, ... +__wur +; + +415  + $ssnf + ( +__cڡ + * +__ri + +__s +, + +416 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +418 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +419 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +420 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +421 #ifde +__REDIRECT + + +425  + `__REDIRECT + ( +fsnf +, ( +FILE + * +__ri + +__am +, + +426 +__cڡ + * +__ri + +__fm +, ...), + +427 +__isoc99_fsnf + +__wur +; + +428  + `__REDIRECT + ( +snf +, ( +__cڡ + * +__ri + +__fm +, ...), + +429 +__isoc99_snf + +__wur +; + +430  + `__REDIRECT + ( +ssnf +, ( +__cڡ + * +__ri + +__s +, + +431 +__cڡ + * +__ri + +__fm +, ...), + +432 +__isoc99_ssnf + +__THROW +; + +434  + $__isoc99_fsnf + ( +FILE + * +__ri + +__am +, + +435 +__cڡ + * +__ri + +__fm +, ... +__wur +; + +436  + $__isoc99_snf + ( +__cڡ + * +__ri + +__fm +, ... +__wur +; + +437  + $__isoc99_ssnf + ( +__cڡ + * +__ri + +__s +, + +438 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +439  + #fsnf + +__isoc99_fsnf + + + ) + +440  + #snf + +__isoc99_snf + + + ) + +441  + #ssnf + +__isoc99_ssnf + + + ) + +445 +__END_NAMESPACE_STD + + +447 #ifdef +__USE_ISOC99 + + +448 +__BEGIN_NAMESPACE_C99 + + +453  + $vfsnf + ( +FILE + * +__ri + +__s +, +__cڡ + *__ri +__fm +, + +454 +_G_va_li + +__g +) + +455 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 2, 0)) +__wur +; + +461  + $vsnf + ( +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +462 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 1, 0)) +__wur +; + +465  + $vssnf + ( +__cڡ + * +__ri + +__s +, + +466 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +467 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 2, 0))); + +469 #i! +defed + +__USE_GNU + \ + +470 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +471 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +472 #ifde +__REDIRECT + + +476  + `__REDIRECT + ( +vfsnf +, + +477 ( +FILE + * +__ri + +__s +, + +478 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +), + +479 +__isoc99_vfsnf +) + +480 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 2, 0)) +__wur +; + +481  + `__REDIRECT + ( +vsnf +, ( +__cڡ + * +__ri + +__fm +, + +482 +_G_va_li + +__g +), +__isoc99_vsnf +) + +483 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 1, 0)) +__wur +; + +484  + `__REDIRECT + ( +vssnf +, + +485 ( +__cڡ + * +__ri + +__s +, + +486 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +), + +487 +__isoc99_vssnf +) + +488 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 2, 0))); + +490  + $__isoc99_vfsnf + ( +FILE + * +__ri + +__s +, + +491 +__cڡ + * +__ri + +__fm +, + +492 +_G_va_li + +__g + +__wur +; + +493  + $__isoc99_vsnf + ( +__cڡ + * +__ri + +__fm +, + +494 +_G_va_li + +__g + +__wur +; + +495  + $__isoc99_vssnf + ( +__cڡ + * +__ri + +__s +, + +496 +__cڡ + * +__ri + +__fm +, + +497 +_G_va_li + +__g + +__THROW +; + +498  + #vfsnf + +__isoc99_vfsnf + + + ) + +499  + #vsnf + +__isoc99_vsnf + + + ) + +500  + #vssnf + +__isoc99_vssnf + + + ) + +504 +__END_NAMESPACE_C99 + + +508 +__BEGIN_NAMESPACE_STD + + +513  + `fgc + ( +FILE + * +__am +); + +514  + `gc + ( +FILE + * +__am +); + +520  + `gch + (); + +521 +__END_NAMESPACE_STD + + +525  + #gc +( +_ + + `_IO_gc + (_) + + ) + +527 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +532  + `gc_uocked + ( +FILE + * +__am +); + +533  + `gch_uocked + (); + +536 #ifde +__USE_MISC + + +543  + `fgc_uocked + ( +FILE + * +__am +); + +547 +__BEGIN_NAMESPACE_STD + + +555  + `utc + ( +__c +, +FILE + * +__am +); + +556  + `putc + ( +__c +, +FILE + * +__am +); + +562  + `putch + ( +__c +); + +563 +__END_NAMESPACE_STD + + +567  + #putc +( +_ch +, +_ + + `_IO_putc + (_ch, _) + + ) + +569 #ifde +__USE_MISC + + +576  + `utc_uocked + ( +__c +, +FILE + * +__am +); + +579 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +584  + `putc_uocked + ( +__c +, +FILE + * +__am +); + +585  + `putch_uocked + ( +__c +); + +589 #i +defed + +__USE_SVID + || defed +__USE_MISC + \ + +590 || ( +defed + +__USE_XOPEN + && !defed +__USE_XOPEN2K +) + +592  + `gw + ( +FILE + * +__am +); + +595  + `putw + ( +__w +, +FILE + * +__am +); + +599 +__BEGIN_NAMESPACE_STD + + +604 * + $fgs + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +) + +605 +__wur +; + +612 * + $gs + (* +__s + +__wur +; + +613 +__END_NAMESPACE_STD + + +615 #ifde +__USE_GNU + + +622 * + $fgs_uocked + (* +__ri + +__s +,  +__n +, + +623 +FILE + * +__ri + +__am + +__wur +; + +627 #ifdef +__USE_XOPEN2K8 + + +638 +_IO_ssize_t + + $__gdim + (** +__ri + +__l +, + +639 +size_t + * +__ri + +__n +,  +__dim +, + +640 +FILE + * +__ri + +__am + +__wur +; + +641 +_IO_ssize_t + + $gdim + (** +__ri + +__l +, + +642 +size_t + * +__ri + +__n +,  +__dim +, + +643 +FILE + * +__ri + +__am + +__wur +; + +651 +_IO_ssize_t + + $gle + (** +__ri + +__l +, + +652 +size_t + * +__ri + +__n +, + +653 +FILE + * +__ri + +__am + +__wur +; + +657 +__BEGIN_NAMESPACE_STD + + +662  + `uts + ( +__cڡ + * +__ri + +__s +, +FILE + *__ri +__am +); + +668  + `puts + ( +__cڡ + * +__s +); + +675  + `ungc + ( +__c +, +FILE + * +__am +); + +682 +size_t + + $d + (* +__ri + +__r +, +size_t + +__size +, + +683 +size_t + +__n +, +FILE + * +__ri + +__am + +__wur +; + +688 +size_t + + `fwre + ( +__cڡ + * +__ri + +__r +, size_ +__size +, + +689 +size_t + +__n +, +FILE + * +__ri + +__s +); + +690 +__END_NAMESPACE_STD + + +692 #ifde +__USE_GNU + + +699  + `uts_uocked + ( +__cڡ + * +__ri + +__s +, + +700 +FILE + * +__ri + +__am +); + +703 #ifde +__USE_MISC + + +710 +size_t + + $d_uocked + (* +__ri + +__r +, +size_t + +__size +, + +711 +size_t + +__n +, +FILE + * +__ri + +__am + +__wur +; + +712 +size_t + + `fwre_uocked + ( +__cڡ + * +__ri + +__r +, size_ +__size +, + +713 +size_t + +__n +, +FILE + * +__ri + +__am +); + +717 +__BEGIN_NAMESPACE_STD + + +722  + `fek + ( +FILE + * +__am +,  +__off +,  +__wh +); + +727  + $l + ( +FILE + * +__am + +__wur +; + +732  + `wd + ( +FILE + * +__am +); + +733 +__END_NAMESPACE_STD + + +740 #i +defed + +__USE_LARGEFILE + || defed +__USE_XOPEN2K + + +741 #ide +__USE_FILE_OFFSET64 + + +746  + `feko + ( +FILE + * +__am +, +__off_t + +__off +,  +__wh +); + +751 +__off_t + + $lo + ( +FILE + * +__am + +__wur +; + +753 #ifde +__REDIRECT + + +754  + `__REDIRECT + ( +feko +, + +755 ( +FILE + * +__am +, +__off64_t + +__off +,  +__wh +), + +756 +feko64 +); + +757 +__off64_t + + `__REDIRECT + ( +lo +, ( +FILE + * +__am +), +lo64 +); + +759  + #feko + +feko64 + + + ) + +760  + #lo + +lo64 + + + ) + +765 +__BEGIN_NAMESPACE_STD + + +766 #ide +__USE_FILE_OFFSET64 + + +771  + `fgpos + ( +FILE + * +__ri + +__am +, +os_t + *__ri +__pos +); + +776  + `fos + ( +FILE + * +__am +, +__cڡ + +os_t + * +__pos +); + +778 #ifde +__REDIRECT + + +779  + `__REDIRECT + ( +fgpos +, ( +FILE + * +__ri + +__am +, + +780 +os_t + * +__ri + +__pos +), +fgpos64 +); + +781  + `__REDIRECT + ( +fos +, + +782 ( +FILE + * +__am +, +__cڡ + +os_t + * +__pos +), +fos64 +); + +784  + #fgpos + +fgpos64 + + + ) + +785  + #fos + +fos64 + + + ) + +788 +__END_NAMESPACE_STD + + +790 #ifde +__USE_LARGEFILE64 + + +791  + `feko64 + ( +FILE + * +__am +, +__off64_t + +__off +,  +__wh +); + +792 +__off64_t + + $lo64 + ( +FILE + * +__am + +__wur +; + +793  + `fgpos64 + ( +FILE + * +__ri + +__am +, +os64_t + *__ri +__pos +); + +794  + `fos64 + ( +FILE + * +__am +, +__cڡ + +os64_t + * +__pos +); + +797 +__BEGIN_NAMESPACE_STD + + +799  + $ + ( +FILE + * +__am + +__THROW +; + +801  + $of + ( +FILE + * +__am + +__THROW + +__wur +; + +803  + $ + ( +FILE + * +__am + +__THROW + +__wur +; + +804 +__END_NAMESPACE_STD + + +806 #ifde +__USE_MISC + + +808  + $_uocked + ( +FILE + * +__am + +__THROW +; + +809  + $of_uocked + ( +FILE + * +__am + +__THROW + +__wur +; + +810  + $_uocked + ( +FILE + * +__am + +__THROW + +__wur +; + +814 +__BEGIN_NAMESPACE_STD + + +819  + ` + ( +__cڡ + * +__s +); + +820 +__END_NAMESPACE_STD + + +826  + ~ + +829 #ifdef +__USE_POSIX + + +831  + $fo + ( +FILE + * +__am + +__THROW + +__wur +; + +834 #ifde +__USE_MISC + + +836  + $fo_uocked + ( +FILE + * +__am + +__THROW + +__wur +; + +840 #i( +defed + +__USE_POSIX2 + || defed +__USE_SVID + || defed +__USE_BSD + || \ + +841 +defed + +__USE_MISC +) + +846 +FILE + * + $pݒ + ( +__cڡ + * +__commd +, __cڡ * +__modes + +__wur +; + +852  + `po + ( +FILE + * +__am +); + +856 #ifdef +__USE_POSIX + + +858 * + $mid + (* +__s + +__THROW +; + +862 #ifde +__USE_XOPEN + + +864 * + `curid + (* +__s +); + +868 #ifdef +__USE_GNU + + +869  +oback +; + +872  + $oback_tf + ( +oback + * +__ri + +__oback +, + +873 +__cڡ + * +__ri + +__fm +, ...) + +874 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +875  + $oback_vtf + ( +oback + * +__ri + +__oback +, + +876 +__cڡ + * +__ri + +__fm +, + +877 +_G_va_li + +__gs +) + +878 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +882 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +886  + $ockfe + ( +FILE + * +__am + +__THROW +; + +890  + $rylockfe + ( +FILE + * +__am + +__THROW + +__wur +; + +893  + $fuockfe + ( +FILE + * +__am + +__THROW +; + +896 #i +defed + +__USE_XOPEN + && !defed +__USE_XOPEN2K + && !defed +__USE_GNU + + +900  + #__ed_gt + + + ) + +901  + ~ + +906 #ifde +__USE_EXTERN_INLINES + + +907  + ~ + +909 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +910  + ~ + +912 #ifde +__LDBL_COMPAT + + +913  + ~ + +916 +__END_DECLS + + + @/usr/include/bits/stdio-ldbl.h + +20 #ide +_STDIO_H + + +24 +__BEGIN_NAMESPACE_STD + + +25 + $__LDBL_REDIR_DECL + ( +rtf +) + +26 + $__LDBL_REDIR_DECL + ( +tf +) + +27 + $__LDBL_REDIR_DECL + ( +rtf +) + +28 + $__LDBL_REDIR_DECL + ( +vrtf +) + +29 + $__LDBL_REDIR_DECL + ( +vtf +) + +30 + $__LDBL_REDIR_DECL + ( +vrtf +) + +31 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +32 && ! +defed + +__REDIRECT + \ + +33 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +34 + $__LDBL_REDIR1_DECL + ( +fsnf +, +__dbl___isoc99_fsnf +) + +35 + $__LDBL_REDIR1_DECL + ( +snf +, +__dbl___isoc99_snf +) + +36 + $__LDBL_REDIR1_DECL + ( +ssnf +, +__dbl___isoc99_ssnf +) + +38 + $__LDBL_REDIR_DECL + ( +fsnf +) + +39 + $__LDBL_REDIR_DECL + ( +snf +) + +40 + $__LDBL_REDIR_DECL + ( +ssnf +) + +42 +__END_NAMESPACE_STD + + +44 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +45 +__BEGIN_NAMESPACE_C99 + + +46 + $__LDBL_REDIR_DECL + ( +tf +) + +47 + $__LDBL_REDIR_DECL + ( +vtf +) + +48 +__END_NAMESPACE_C99 + + +51 #ifdef +__USE_ISOC99 + + +52 +__BEGIN_NAMESPACE_C99 + + +53 #i! +defed + +__USE_GNU + && !defed +__REDIRECT + \ + +54 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +55 + $__LDBL_REDIR1_DECL + ( +vfsnf +, +__dbl___isoc99_vfsnf +) + +56 + $__LDBL_REDIR1_DECL + ( +vsnf +, +__dbl___isoc99_vsnf +) + +57 + $__LDBL_REDIR1_DECL + ( +vssnf +, +__dbl___isoc99_vssnf +) + +59 + $__LDBL_REDIR_DECL + ( +vfsnf +) + +60 + $__LDBL_REDIR_DECL + ( +vssnf +) + +61 + $__LDBL_REDIR_DECL + ( +vsnf +) + +63 +__END_NAMESPACE_C99 + + +66 #ifde +__USE_GNU + + +67 + $__LDBL_REDIR_DECL + ( +vdtf +) + +68 + $__LDBL_REDIR_DECL + ( +dtf +) + +69 + $__LDBL_REDIR_DECL + ( +vartf +) + +70 + $__LDBL_REDIR_DECL + ( +__artf +) + +71 + $__LDBL_REDIR_DECL + ( +artf +) + +72 + $__LDBL_REDIR_DECL + ( +oback_tf +) + +73 + $__LDBL_REDIR_DECL + ( +oback_vtf +) + +76 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +77 + $__LDBL_REDIR_DECL + ( +__rtf_chk +) + +78 + $__LDBL_REDIR_DECL + ( +__vrtf_chk +) + +79 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +80 + $__LDBL_REDIR_DECL + ( +__tf_chk +) + +81 + $__LDBL_REDIR_DECL + ( +__vtf_chk +) + +83 #i +__USE_FORTIFY_LEVEL + > 1 + +84 + $__LDBL_REDIR_DECL + ( +__rtf_chk +) + +85 + $__LDBL_REDIR_DECL + ( +__tf_chk +) + +86 + $__LDBL_REDIR_DECL + ( +__vrtf_chk +) + +87 + $__LDBL_REDIR_DECL + ( +__vtf_chk +) + +88 #ifde +__USE_GNU + + +89 + $__LDBL_REDIR_DECL + ( +__artf_chk +) + +90 + $__LDBL_REDIR_DECL + ( +__vartf_chk +) + +91 + $__LDBL_REDIR_DECL + ( +__dtf_chk +) + +92 + $__LDBL_REDIR_DECL + ( +__vdtf_chk +) + +93 + $__LDBL_REDIR_DECL + ( +__oback_tf_chk +) + +94 + $__LDBL_REDIR_DECL + ( +__oback_vtf_chk +) + + @/usr/include/bits/stdio.h + +20 #ide +_STDIO_H + + +24 #ide +__ex_le + + +25  + #__STDIO_INLINE + +le + + + ) + +27  + #__STDIO_INLINE + +__ex_le + + + ) + +31 #ifde +__USE_EXTERN_INLINES + + +34 #i!( +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le +) + +36 +__STDIO_INLINE +  + +37 + $vtf + ( +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +39  + `vrtf + ( +dout +, +__fmt +, +__g +); + +40 + } +} + +44 +__STDIO_INLINE +  + +45 + $gch + () + +47  + `_IO_gc + ( +d +); + +48 + } +} + +51 #ifde +__USE_MISC + + +53 +__STDIO_INLINE +  + +54 + $fgc_uocked + ( +FILE + * +__ +) + +56  + `_IO_gc_uocked + ( +__ +); + +57 + } +} + +61 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +63 +__STDIO_INLINE +  + +64 + $gc_uocked + ( +FILE + * +__ +) + +66  + `_IO_gc_uocked + ( +__ +); + +67 + } +} + +70 +__STDIO_INLINE +  + +71 + $gch_uocked + () + +73  + `_IO_gc_uocked + ( +d +); + +74 + } +} + +79 +__STDIO_INLINE +  + +80 + $putch + ( +__c +) + +82  + `_IO_putc + ( +__c +, +dout +); + +83 + } +} + +86 #ifde +__USE_MISC + + +88 +__STDIO_INLINE +  + +89 + $utc_uocked + ( +__c +, +FILE + * +__am +) + +91  + `_IO_putc_uocked + ( +__c +, +__am +); + +92 + } +} + +96 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +98 +__STDIO_INLINE +  + +99 + $putc_uocked + ( +__c +, +FILE + * +__am +) + +101  + `_IO_putc_uocked + ( +__c +, +__am +); + +102 + } +} + +105 +__STDIO_INLINE +  + +106 + $putch_uocked + ( +__c +) + +108  + `_IO_putc_uocked + ( +__c +, +dout +); + +109 + } +} + +113 #ifdef +__USE_GNU + + +115 +__STDIO_INLINE + +_IO_ssize_t + + +116 + $gle + (** +__l +, +size_t + * +__n +, +FILE + * +__am +) + +118  + `__gdim + ( +__l +, +__n +, '\n', +__am +); + +119 + } +} + +123 #ifde +__USE_MISC + + +125 +__STDIO_INLINE +  + +126 +__NTH + ( + $of_uocked + ( +FILE + * +__am +)) + +128  + `_IO_of_uocked + ( +__am +); + +129 + } +} + +132 +__STDIO_INLINE +  + +133 +__NTH + ( + $_uocked + ( +FILE + * +__am +)) + +135  + `_IO__uocked + ( +__am +); + +136 + } +} + +142 #i +defed + +__USE_MISC + && defed +__GNUC__ + && defed +__OPTIMIZE__ + \ + +143 && ! +defed + + g__lulus + + +145  + #d_uocked +( +r +, +size +, +n +, +am +) \ + +146 ( + `__exnsi__ + (( + `__but_cڡt_p + ( +size +&& __but_cڡt_( +n +) \ + +147 && ( +size_t +( +size +* (size_t( +n +) <= 8 \ + +148 && ( +size_t +( +size +) != 0) \ + +149 ? ({ * +__r + = (*( +r +); \ + +150 +FILE + * +__am + = ( +am +); \ + +151 +size_t + +__t +; \ + +152  +__t + = ( +size_t +( +size +* (size_t( +n +); \ + +153 +__t + > 0; --__cnt) \ + +155  +__c + = + `_IO_gc_uocked + ( +__am +); \ + +156 i( +__c + = +EOF +) \ + +158 * +__r +++ = +__c +; \ + +160 (( +size_t +( +size +* (size_t( +n +- +__t +) \ + +161 / ( +size_t +( +size +); }) \ + +162 : ((( + `__but_cڡt_p + ( +size +&& ( +size_t +) (size) == 0) \ + +163 || ( + `__but_cڡt_p + ( +n +&& ( +size_t +) (n) == 0)) \ + +165 ? ((( +r +), (( +am +), (( +size +), \ + +166 (( +n +), ( +size_t +) 0) \ + +167 : + `d_uocked + ( +r +, +size +, +n +, +am +)))) + + ) + +169  + #fwre_uocked +( +r +, +size +, +n +, +am +) \ + +170 ( + `__exnsi__ + (( + `__but_cڡt_p + ( +size +&& __but_cڡt_( +n +) \ + +171 && ( +size_t +( +size +* (size_t( +n +) <= 8 \ + +172 && ( +size_t +( +size +) != 0) \ + +173 ? ({ cڡ * +__r + = (cڡ *( +r +); \ + +174 +FILE + * +__am + = ( +am +); \ + +175 +size_t + +__t +; \ + +176  +__t + = ( +size_t +( +size +* (size_t( +n +); \ + +177 +__t + > 0; --__cnt) \ + +178 i( + `_IO_putc_uocked + (* +__r +++, +__am += +EOF +) \ + +180 (( +size_t +( +size +* (size_t( +n +- +__t +) \ + +181 / ( +size_t +( +size +); }) \ + +182 : ((( + `__but_cڡt_p + ( +size +&& ( +size_t +) (size) == 0) \ + +183 || ( + `__but_cڡt_p + ( +n +&& ( +size_t +) (n) == 0)) \ + +185 ? ((( +r +), (( +am +), (( +size +), \ + +186 (( +n +), ( +size_t +) 0) \ + +187 : + `fwre_uocked + ( +r +, +size +, +n +, +am +)))) + + ) + +191 #unde +__STDIO_INLINE + + + @/usr/include/bits/stdio2.h + +20 #ide +_STDIO_H + + +24  + $__rtf_chk + (* +__ri + +__s +,  +__ag +, +size_t + +__ +, + +25 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +26  + $__vrtf_chk + (* +__ri + +__s +,  +__ag +, +size_t + +__ +, + +27 +__cڡ + * +__ri + +__fm +, + +28 +_G_va_li + +__ + +__THROW +; + +30 #ifde +__va_g_ck + + +31 +__ex_ways_le +  + +32 + `__NTH + ( + $rtf + (* +__ri + +__s +, +__cڡ + *__ri +__fmt +, ...)) + +34  + `__but___rtf_chk + ( +__s +, +__USE_FORTIFY_LEVEL + - 1, + +35 + `__bos + ( +__s +), +__fmt +, + `__va_g_ck + ()); + +36 + } +} + +37 #i! +defed + +__lulus + + +38  + #rtf +( +r +, ...) \ + +39 + `__but___rtf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +40 +__VA_ARGS__ +) + + ) + +43 +__ex_ways_le +  + +44 +__NTH + ( + $vrtf + (* +__ri + +__s +, +__cڡ + *__ri +__fmt +, + +45 +_G_va_li + +__ +)) + +47  + `__but___vrtf_chk + ( +__s +, +__USE_FORTIFY_LEVEL + - 1, + +48 + `__bos + ( +__s +), +__fmt +, +__ +); + +49 + } +} + +51 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +53  + $__tf_chk + (* +__ri + +__s +, +size_t + +__n +,  +__ag +, + +54 +size_t + +__ +, +__cڡ + * +__ri + +__fm +, + +55 ... +__THROW +; + +56  + $__vtf_chk + (* +__ri + +__s +, +size_t + +__n +,  +__ag +, + +57 +size_t + +__ +, +__cڡ + * +__ri + +__fm +, + +58 +_G_va_li + +__ + +__THROW +; + +60 #ifde +__va_g_ck + + +61 +__ex_ways_le +  + +62 + `__NTH + ( + $tf + (* +__ri + +__s +, +size_t + +__n +, + +63 +__cڡ + * +__ri + +__fmt +, ...)) + +65  + `__but___tf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +66 + `__bos + ( +__s +), +__fmt +, + `__va_g_ck + ()); + +67 + } +} + +68 #i! +defed + +__lulus + + +69  + #tf +( +r +, +n +, ...) \ + +70 + `__but___tf_chk + ( +r +, +n +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +71 +__VA_ARGS__ +) + + ) + +74 +__ex_ways_le +  + +75 +__NTH + ( + $vtf + (* +__ri + +__s +, +size_t + +__n +, + +76 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +)) + +78  + `__but___vtf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +79 + `__bos + ( +__s +), +__fmt +, +__ +); + +80 + } +} + +84 #i +__USE_FORTIFY_LEVEL + > 1 + +86  +__rtf_chk + ( +FILE + * +__ri + +__am +,  +__ag +, + +87 +__cڡ + * +__ri + +__fm +, ...); + +88  +__tf_chk + ( +__ag +, +__cڡ + * +__ri + +__fm +, ...); + +89  +__vrtf_chk + ( +FILE + * +__ri + +__am +,  +__ag +, + +90 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__ +); + +91  +__vtf_chk + ( +__ag +, +__cڡ + * +__ri + +__fm +, + +92 +_G_va_li + +__ +); + +94 #ifde +__va_g_ck + + +95 +__ex_ways_le +  + +96 + $rtf + ( +FILE + * +__ri + +__am +, +__cڡ + *__ri +__fmt +, ...) + +98  + `__rtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +99 + `__va_g_ck + ()); + +100 + } +} + +102 +__ex_ways_le +  + +103 + $tf + ( +__cڡ + * +__ri + +__fmt +, ...) + +105  + `__tf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + `__va_g_ck + ()); + +106 + } +} + +107 #i! +defed + +__lulus + + +108  + #tf +(...) \ + +109 + `__tf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +110  + #rtf +( +am +, ...) \ + +111 + `__rtf_chk + ( +am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +114 +__ex_ways_le +  + +115 + $vtf + ( +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +) + +117 #ifde +__USE_EXTERN_INLINES + + +118  + `__vrtf_chk + ( +dout +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +120  + `__vtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +122 + } +} + +124 +__ex_ways_le +  + +125 + $vrtf + ( +FILE + * +__ri + +__am +, + +126 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +) + +128  + `__vrtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +129 + } +} + +131 #ifde +__USE_GNU + + +133  + $__artf_chk + (** +__ri + +__r +,  +__ag +, + +134 +__cڡ + * +__ri + +__fmt +, ...) + +135 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 3, 4)) +__wur +; + +136  + $__vartf_chk + (** +__ri + +__r +,  +__ag +, + +137 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +138 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 3, 0)) +__wur +; + +139  + $__dtf_chk + ( +__fd +,  +__ag +, +__cڡ + * +__ri + +__fmt +, + +140 ... + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +141  + $__vdtf_chk + ( +__fd +,  +__ag +, + +142 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +143 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +144  + $__oback_tf_chk + ( +oback + * +__ri + +__oback +, + +145  +__ag +, +__cڡ + * +__ri + +__fm +, + +147 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +148  + $__oback_vtf_chk + ( +oback + * +__ri + +__oback +, + +149  +__ag +, + +150 +__cڡ + * +__ri + +__fm +, + +151 +_G_va_li + +__gs +) + +152 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +154 #ifde +__va_g_ck + + +155 +__ex_ways_le +  + +156 + `__NTH + ( + $artf + (** +__ri + +__r +, +__cڡ + *__ri +__fmt +, ...)) + +158  + `__artf_chk + ( +__r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +159 + `__va_g_ck + ()); + +160 + } +} + +162 +__ex_ways_le +  + +163 +__NTH + ( + $__artf + (** +__ri + +__r +, +__cڡ + *__ri +__fmt +, + +166  + `__artf_chk + ( +__r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +167 + `__va_g_ck + ()); + +168 + } +} + +170 +__ex_ways_le +  + +171 + $dtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, ...) + +173  + `__dtf_chk + ( +__fd +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +174 + `__va_g_ck + ()); + +175 + } +} + +177 +__ex_ways_le +  + +178 +__NTH + ( + $oback_tf + ( +oback + * +__ri + +__oback +, + +179 +__cڡ + * +__ri + +__fmt +, ...)) + +181  + `__oback_tf_chk + ( +__oback +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +182 + `__va_g_ck + ()); + +183 + } +} + +184 #i! +defed + +__lulus + + +185  + #artf +( +r +, ...) \ + +186 + `__artf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +187  + #__artf +( +r +, ...) \ + +188 + `__artf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +189  + #dtf +( +fd +, ...) \ + +190 + `__dtf_chk + ( +fd +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +191  + #oback_tf +( +oback +, ...) \ + +192 + `__oback_tf_chk + ( +oback +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +195 +__ex_ways_le +  + +196 +__NTH + ( + $vartf + (** +__ri + +__r +, +__cڡ + *__ri +__fmt +, + +197 +_G_va_li + +__ +)) + +199  + `__vartf_chk + ( +__r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +200 + } +} + +202 +__ex_ways_le +  + +203 + $vdtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +) + +205  + `__vdtf_chk + ( +__fd +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +206 + } +} + +208 +__ex_ways_le +  + +209 +__NTH + ( + $oback_vtf + ( +oback + * +__ri + +__oback +, + +210 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +)) + +212  + `__oback_vtf_chk + ( +__oback +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +213 +__ +); + +214 + } +} + +220 * + $__gs_chk + (* +__r +, +size_t + +__wur +; + +221 * + `__REDIRECT + ( +__gs_wn +, (* +__r +), +gs +) + +222 +__wur + + `__wljr + ("please use fgets or getline instead, gets can't " + +225 +__ex_ways_le + +__wur + * + +226 + $gs + (* +__r +) + +228 i( + `__bos + ( +__r +!( +size_t +) -1) + +229  + `__gs_chk + ( +__r +, + `__bos + (__str)); + +230  + `__gs_wn + ( +__r +); + +231 + } +} + +233 * + $__fgs_chk + (* +__ri + +__s +, +size_t + +__size +,  +__n +, + +234 +FILE + * +__ri + +__am + +__wur +; + +235 * + `__REDIRECT + ( +__fgs_s +, + +236 (* +__ri + +__s +,  +__n +, + +237 +FILE + * +__ri + +__am +), +fgs + +__wur +; + +238 * + `__REDIRECT + ( +__fgs_chk_wn +, + +239 (* +__ri + +__s +, +size_t + +__size +,  +__n +, + +240 +FILE + * +__ri + +__am +), +__fgs_chk +) + +241 +__wur + + `__wljr + ("fgets called with bigger sizehanength " + +244 +__ex_ways_le + +__wur + * + +245 + $fgs + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +) + +247 i( + `__bos + ( +__s +!( +size_t +) -1) + +249 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +250  + `__fgs_chk + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +252 i(( +size_t + +__n + > + `__bos + ( +__s +)) + +253  + `__fgs_chk_wn + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +255  + `__fgs_s + ( +__s +, +__n +, +__am +); + +256 + } +} + +258 +size_t + + $__d_chk + (* +__ri + +__r +, +size_t + +__ +, + +259 +size_t + +__size +, size_ +__n +, + +260 +FILE + * +__ri + +__am + +__wur +; + +261 +size_t + + `__REDIRECT + ( +__d_s +, + +262 (* +__ri + +__r +, +size_t + +__size +, + +263 +size_t + +__n +, +FILE + * +__ri + +__am +), + +264 +d + +__wur +; + +265 +size_t + + `__REDIRECT + ( +__d_chk_wn +, + +266 (* +__ri + +__r +, +size_t + +__ +, + +267 +size_t + +__size +, size_ +__n +, + +268 +FILE + * +__ri + +__am +), + +269 +__d_chk +) + +270 +__wur + + `__wljr + ("fread called with bigger size *membhanength " + +273 +__ex_ways_le + +__wur + +size_t + + +274 + $d + (* +__ri + +__r +, +size_t + +__size +, size_ +__n +, + +275 +FILE + * +__ri + +__am +) + +277 i( + `__bos0 + ( +__r +!( +size_t +) -1) + +279 i(! + `__but_cڡt_p + ( +__size +) + +280 || ! + `__but_cڡt_p + ( +__n +) + +281 || ( +__size + | +__n +>((( +size_t +) 1) << (8 *  (size_t) / 2))) + +282  + `__d_chk + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, +__am +); + +284 i( +__size + * +__n + > + `__bos0 + ( +__r +)) + +285  + `__d_chk_wn + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, +__am +); + +287  + `__d_s + ( +__r +, +__size +, +__n +, +__am +); + +288 + } +} + +290 #ifde +__USE_GNU + + +291 * + $__fgs_uocked_chk + (* +__ri + +__s +, +size_t + +__size +, + +292  +__n +, +FILE + * +__ri + +__am + +__wur +; + +293 * + `__REDIRECT + ( +__fgs_uocked_s +, + +294 (* +__ri + +__s +,  +__n +, + +295 +FILE + * +__ri + +__am +), +fgs_uocked + +__wur +; + +296 * + `__REDIRECT + ( +__fgs_uocked_chk_wn +, + +297 (* +__ri + +__s +, +size_t + +__size +,  +__n +, + +298 +FILE + * +__ri + +__am +), +__fgs_uocked_chk +) + +299 +__wur + + `__wljr + ("fgets_unlocked called with bigger sizehanength " + +302 +__ex_ways_le + +__wur + * + +303 + $fgs_uocked + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +) + +305 i( + `__bos + ( +__s +!( +size_t +) -1) + +307 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +308  + `__fgs_uocked_chk + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +310 i(( +size_t + +__n + > + `__bos + ( +__s +)) + +311  + `__fgs_uocked_chk_wn + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +313  + `__fgs_uocked_s + ( +__s +, +__n +, +__am +); + +314 + } +} + +317 #ifde +__USE_MISC + + +318 #unde +d_uocked + + +319 +size_t + + $__d_uocked_chk + (* +__ri + +__r +, +size_t + +__ +, + +320 +size_t + +__size +, size_ +__n +, + +321 +FILE + * +__ri + +__am + +__wur +; + +322 +size_t + + `__REDIRECT + ( +__d_uocked_s +, + +323 (* +__ri + +__r +, +size_t + +__size +, + +324 +size_t + +__n +, +FILE + * +__ri + +__am +), + +325 +d_uocked + +__wur +; + +326 +size_t + + `__REDIRECT + ( +__d_uocked_chk_wn +, + +327 (* +__ri + +__r +, +size_t + +__ +, + +328 +size_t + +__size +, size_ +__n +, + +329 +FILE + * +__ri + +__am +), + +330 +__d_uocked_chk +) + +331 +__wur + + `__wljr + ("fread_unlocked called with bigger size *membhan " + +334 +__ex_ways_le + +__wur + +size_t + + +335 + $d_uocked + (* +__ri + +__r +, +size_t + +__size +, size_ +__n +, + +336 +FILE + * +__ri + +__am +) + +338 i( + `__bos0 + ( +__r +!( +size_t +) -1) + +340 i(! + `__but_cڡt_p + ( +__size +) + +341 || ! + `__but_cڡt_p + ( +__n +) + +342 || ( +__size + | +__n +>((( +size_t +) 1) << (8 *  (size_t) / 2))) + +343  + `__d_uocked_chk + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, + +344 +__am +); + +346 i( +__size + * +__n + > + `__bos0 + ( +__r +)) + +347  + `__d_uocked_chk_wn + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, + +348 +__am +); + +351 #ifde +__USE_EXTERN_INLINES + + +352 i( + `__but_cڡt_p + ( +__size +) + +353 && + `__but_cڡt_p + ( +__n +) + +354 && ( +__size + | +__n +< ((( +size_t +) 1) << (8 *  (size_t) / 2)) + +355 && +__size + * +__n + <= 8) + +357 +size_t + +__t + = +__size + * +__n +; + +358 * +__ + = (* +__r +; + +359 i( +__t + == 0) + +362 ; +__t + > 0; --__cnt) + +364  +__c + = + `_IO_gc_uocked + ( +__am +); + +365 i( +__c + = +EOF +) + +367 * +__ +++ = +__c +; + +369  ( +__ + - (* +__r +/ +__size +; + +372  + `__d_uocked_s + ( +__r +, +__size +, +__n +, +__am +); + +373 + } +} + + @/usr/include/bits/stdio_lim.h + +19 #i! +defed + +_STDIO_H + && !defed +__ed_FOPEN_MAX + && !defed +__ed_IOV_MAX + + +23 #ifde +_STDIO_H + + +24  + #L_tmam + 20 + + ) + +25  + #TMP_MAX + 238328 + + ) + +26  + #FILENAME_MAX + 4096 + + ) + +28 #ifde +__USE_POSIX + + +29  + #L_mid + 9 + + ) + +30 #i! +defed + +__USE_XOPEN2K + || defed +__USE_GNU + + +31  + #L_curid + 9 + + ) + +36 #i +defed + +__ed_FOPEN_MAX + || defed +_STDIO_H + + +37 #unde +FOPEN_MAX + + +38  + #FOPEN_MAX + 16 + + ) + +41 #i +defed + +__ed_IOV_MAX + && !defed +IOV_MAX + + +42  + #IOV_MAX + 1024 + + ) + + @/usr/include/bits/sys_errlist.h + +20 #ide +_STDIO_H + + +26 #ifde +__USE_BSD + + +27  +sys_ü +; + +28 +__cڡ + *__cڡ +sys_i +[]; + +30 #ifde +__USE_GNU + + +31  +_sys_ü +; + +32 +__cڡ + *__cڡ +_sys_i +[]; + + @/usr/include/bits/types.h + +24 #idef +_BITS_TYPES_H + + +25  + #_BITS_TYPES_H + 1 + + ) + +27  + ~ + +28  + ~ + +31  + t__u_ch +; + +32  + t__u_sht +; + +33  + t__u_t +; + +34  + t__u_lg +; + +37 sigd  + t__t8_t +; + +38  + t__ut8_t +; + +39 sigd  + t__t16_t +; + +40  + t__ut16_t +; + +41 sigd  + t__t32_t +; + +42  + t__ut32_t +; + +43 #i +__WORDSIZE + == 64 + +44 sigd  + t__t64_t +; + +45  + t__ut64_t +; + +46 #i +defed + +__GLIBC_HAVE_LONG_LONG + + +47 +__exnsi__ + sigd  + t__t64_t +; + +48 +__exnsi__ +  + t__ut64_t +; + +52 #i +__WORDSIZE + == 64 + +53  + t__quad_t +; + +54  + t__u_quad_t +; + +55 #i +defed + +__GLIBC_HAVE_LONG_LONG + + +56 +__exnsi__ +  + t__quad_t +; + +57 +__exnsi__ +  + t__u_quad_t +; + +61  + m__v +[2]; + +62 } + t__quad_t +; + +65 +__u_lg + + m__v +[2]; + +66 } + t__u_quad_t +; + +99  + #__S16_TYPE +  + + ) + +100  + #__U16_TYPE +  + + ) + +101  + #__S32_TYPE +  + + ) + +102  + #__U32_TYPE +  + + ) + +103  + #__SLONGWORD_TYPE +  + + ) + +104  + #__ULONGWORD_TYPE +  + + ) + +105 #i +__WORDSIZE + == 32 + +106  + #__SQUAD_TYPE + +__quad_t + + + ) + +107  + #__UQUAD_TYPE + +__u_quad_t + + + ) + +108  + #__SWORD_TYPE +  + + ) + +109  + #__UWORD_TYPE +  + + ) + +110  + #__SLONG32_TYPE +  + + ) + +111  + #__ULONG32_TYPE +  + + ) + +112  + #__S64_TYPE + +__quad_t + + + ) + +113  + #__U64_TYPE + +__u_quad_t + + + ) + +116  + #__STD_TYPE + +__exnsi__ +  + + ) + +117 #i +__WORDSIZE + == 64 + +118  + t__SQUAD_TYPE +  + + ) + +119  + t__UQUAD_TYPE +  + + ) + +120  + t__SWORD_TYPE +  + + ) + +121  + t__UWORD_TYPE +  + + ) + +122  + t__SLONG32_TYPE +  + + ) + +123  + t__ULONG32_TYPE +  + + ) + +124  + t__S64_TYPE +  + + ) + +125  + t__U64_TYPE +  + + ) + +127  + t__STD_TYPE +  + + ) + +131  + ~ + +134 +__STD_TYPE + + t__DEV_T_TYPE + + t__dev_t +; + +135 +__STD_TYPE + +__UID_T_TYPE + + g__uid_t +; + +136 +__STD_TYPE + +__GID_T_TYPE + + g__gid_t +; + +137 +__STD_TYPE + +__INO_T_TYPE + + g__o_t +; + +138 +__STD_TYPE + +__INO64_T_TYPE + + g__o64_t +; + +139 +__STD_TYPE + +__MODE_T_TYPE + + g__mode_t +; + +140 +__STD_TYPE + +__NLINK_T_TYPE + + g__ƚk_t +; + +141 +__STD_TYPE + +__OFF_T_TYPE + + g__off_t +; + +142 +__STD_TYPE + +__OFF64_T_TYPE + + g__off64_t +; + +143 +__STD_TYPE + +__PID_T_TYPE + + g__pid_t +; + +144 +__STD_TYPE + +__FSID_T_TYPE + + g__fsid_t +; + +145 +__STD_TYPE + +__CLOCK_T_TYPE + + g__ock_t +; + +146 +__STD_TYPE + +__RLIM_T_TYPE + + g__im_t +; + +147 +__STD_TYPE + +__RLIM64_T_TYPE + + g__im64_t +; + +148 +__STD_TYPE + +__ID_T_TYPE + + g__id_t +; + +149 +__STD_TYPE + +__TIME_T_TYPE + + g__time_t +; + +150 +__STD_TYPE + +__USECONDS_T_TYPE + + g__ucds_t +; + +151 +__STD_TYPE + +__SUSECONDS_T_TYPE + + g__sucds_t +; + +153 +__STD_TYPE + +__DADDR_T_TYPE + + g__daddr_t +; + +154 +__STD_TYPE + +__SWBLK_T_TYPE + + g__swblk_t +; + +155 +__STD_TYPE + +__KEY_T_TYPE + + g__key_t +; + +158 +__STD_TYPE + +__CLOCKID_T_TYPE + + g__ockid_t +; + +161 +__STD_TYPE + +__TIMER_T_TYPE + + g__tim_t +; + +164 +__STD_TYPE + +__BLKSIZE_T_TYPE + + g__blksize_t +; + +169 +__STD_TYPE + +__BLKCNT_T_TYPE + + g__blkt_t +; + +170 +__STD_TYPE + +__BLKCNT64_T_TYPE + + g__blkt64_t +; + +173 +__STD_TYPE + +__FSBLKCNT_T_TYPE + + g__fsblkt_t +; + +174 +__STD_TYPE + +__FSBLKCNT64_T_TYPE + + g__fsblkt64_t +; + +177 +__STD_TYPE + +__FSFILCNT_T_TYPE + + g__fsft_t +; + +178 +__STD_TYPE + +__FSFILCNT64_T_TYPE + + g__fsft64_t +; + +180 +__STD_TYPE + +__SSIZE_T_TYPE + + g__ssize_t +; + +184  +__off64_t + + t__loff_t +; + +185  +__quad_t + * + t__qaddr_t +; + +186 * + t__ddr_t +; + +189 +__STD_TYPE + +__SWORD_TYPE + + g___t +; + +192 +__STD_TYPE + +__U32_TYPE + + g__sockn_t +; + +195 #unde +__STD_TYPE + + + @/usr/include/features.h + +19 #idef +_FEATURES_H + + +20  + #_FEATURES_H + 1 + + ) + +95 #unde +__USE_ISOC99 + + +96 #unde +__USE_ISOC95 + + +97 #unde +__USE_POSIX + + +98 #unde +__USE_POSIX2 + + +99 #unde +__USE_POSIX199309 + + +100 #unde +__USE_POSIX199506 + + +101 #unde +__USE_XOPEN + + +102 #unde +__USE_XOPEN_EXTENDED + + +103 #unde +__USE_UNIX98 + + +104 #unde +__USE_XOPEN2K + + +105 #unde +__USE_XOPEN2K8 + + +106 #unde +__USE_LARGEFILE + + +107 #unde +__USE_LARGEFILE64 + + +108 #unde +__USE_FILE_OFFSET64 + + +109 #unde +__USE_BSD + + +110 #unde +__USE_SVID + + +111 #unde +__USE_MISC + + +112 #unde +__USE_ATFILE + + +113 #unde +__USE_GNU + + +114 #unde +__USE_REENTRANT + + +115 #unde +__USE_FORTIFY_LEVEL + + +116 #unde +__FAVOR_BSD + + +117 #unde +__KERNEL_STRICT_NAMES + + +121 #ide +_LOOSE_KERNEL_NAMES + + +122  + #__KERNEL_STRICT_NAMES + + + ) + +126  + #__USE_ANSI + 1 + + ) + +135 #i +defed + +__GNUC__ + && defed +__GNUC_MINOR__ + + +136  + #__GNUC_PREREQ +( +maj +, +m +) \ + +137 (( +__GNUC__ + << 16+ +__GNUC_MINOR__ + >(( +maj +<< 16+ ( +m +)) + + ) + +139  + #__GNUC_PREREQ +( +maj +, +m +0 + + ) + +144 #i +defed + +_BSD_SOURCE + && \ + +145 !( +defed + + g_POSIX_SOURCE + || defed + g_POSIX_C_SOURCE + || \ + +146 +defed + + g_XOPEN_SOURCE + || defed + g_XOPEN_SOURCE_EXTENDED + || \ + +147 +defed + + g_GNU_SOURCE + || defed + g_SVID_SOURCE +) + +148  + #__FAVOR_BSD + 1 + + ) + +152 #ifde +_GNU_SOURCE + + +153 #unde +_ISOC99_SOURCE + + +154  + #_ISOC99_SOURCE + 1 + + ) + +155 #unde +_POSIX_SOURCE + + +156  + #_POSIX_SOURCE + 1 + + ) + +157 #unde +_POSIX_C_SOURCE + + +158  + #_POSIX_C_SOURCE + 200809L + + ) + +159 #unde +_XOPEN_SOURCE + + +160  + #_XOPEN_SOURCE + 700 + + ) + +161 #unde +_XOPEN_SOURCE_EXTENDED + + +162  + #_XOPEN_SOURCE_EXTENDED + 1 + + ) + +163 #unde +_LARGEFILE64_SOURCE + + +164  + #_LARGEFILE64_SOURCE + 1 + + ) + +165 #unde +_BSD_SOURCE + + +166  + #_BSD_SOURCE + 1 + + ) + +167 #unde +_SVID_SOURCE + + +168  + #_SVID_SOURCE + 1 + + ) + +169 #unde +_ATFILE_SOURCE + + +170  + #_ATFILE_SOURCE + 1 + + ) + +175 #i(! +defed + +__STRICT_ANSI__ + && !defed +_ISOC99_SOURCE + && \ + +176 ! +defed + + g_POSIX_SOURCE + && !defed + g_POSIX_C_SOURCE + && \ + +177 ! +defed + + g_XOPEN_SOURCE + && !defed + g_XOPEN_SOURCE_EXTENDED + && \ + +178 ! +defed + + g_BSD_SOURCE + && !defed + g_SVID_SOURCE +) + +179  + #_BSD_SOURCE + 1 + + ) + +180  + #_SVID_SOURCE + 1 + + ) + +187 #i( +defed + +_ISOC99_SOURCE + || defed +_ISOC9X_SOURCE + \ + +188 || ( +defed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L)) + +189  + #__USE_ISOC99 + 1 + + ) + +193 #i( +defed + +_ISOC99_SOURCE + || defed +_ISOC9X_SOURCE + \ + +194 || ( +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199409L)) + +195  + #__USE_ISOC95 + 1 + + ) + +200 #i((! +defed + +__STRICT_ANSI__ + || ( +_XOPEN_SOURCE + - 0) >= 500) && \ + +201 ! +defed + +_POSIX_SOURCE + && !defed +_POSIX_C_SOURCE +) + +202  + #_POSIX_SOURCE + 1 + + ) + +203 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 500 + +204  + #_POSIX_C_SOURCE + 2 + + ) + +205 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 600 + +206  + #_POSIX_C_SOURCE + 199506L + + ) + +207 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 700 + +208  + #_POSIX_C_SOURCE + 200112L + + ) + +210  + #_POSIX_C_SOURCE + 200809L + + ) + +212  + #__USE_POSIX_IMPLICITLY + 1 + + ) + +215 #i +defed + +_POSIX_SOURCE + || +_POSIX_C_SOURCE + >1 || defed +_XOPEN_SOURCE + + +216  + #__USE_POSIX + 1 + + ) + +219 #i +defed + +_POSIX_C_SOURCE + && _POSIX_C_SOURCE >2 || defed +_XOPEN_SOURCE + + +220  + #__USE_POSIX2 + 1 + + ) + +223 #i( +_POSIX_C_SOURCE + - 0) >= 199309L + +224  + #__USE_POSIX199309 + 1 + + ) + +227 #i( +_POSIX_C_SOURCE + - 0) >= 199506L + +228  + #__USE_POSIX199506 + 1 + + ) + +231 #i( +_POSIX_C_SOURCE + - 0) >= 200112L + +232  + #__USE_XOPEN2K + 1 + + ) + +233 #unde +__USE_ISOC99 + + +234  + #__USE_ISOC99 + 1 + + ) + +237 #i( +_POSIX_C_SOURCE + - 0) >= 200809L + +238  + #__USE_XOPEN2K8 + 1 + + ) + +239 #unde +_ATFILE_SOURCE + + +240  + #_ATFILE_SOURCE + 1 + + ) + +243 #ifdef +_XOPEN_SOURCE + + +244  + #__USE_XOPEN + 1 + + ) + +245 #i( +_XOPEN_SOURCE + - 0) >= 500 + +246  + #__USE_XOPEN_EXTENDED + 1 + + ) + +247  + #__USE_UNIX98 + 1 + + ) + +248 #unde +_LARGEFILE_SOURCE + + +249  + #_LARGEFILE_SOURCE + 1 + + ) + +250 #i( +_XOPEN_SOURCE + - 0) >= 600 + +251 #i( +_XOPEN_SOURCE + - 0) >= 700 + +252  + #__USE_XOPEN2K8 + 1 + + ) + +254  + #__USE_XOPEN2K + 1 + + ) + +255 #unde +__USE_ISOC99 + + +256  + #__USE_ISOC99 + 1 + + ) + +259 #ifde +_XOPEN_SOURCE_EXTENDED + + +260  + #__USE_XOPEN_EXTENDED + 1 + + ) + +265 #ifde +_LARGEFILE_SOURCE + + +266  + #__USE_LARGEFILE + 1 + + ) + +269 #ifde +_LARGEFILE64_SOURCE + + +270  + #__USE_LARGEFILE64 + 1 + + ) + +273 #i +defed + +_FILE_OFFSET_BITS + && _FILE_OFFSET_BITS == 64 + +274  + #__USE_FILE_OFFSET64 + 1 + + ) + +277 #i +defed + +_BSD_SOURCE + || defed +_SVID_SOURCE + + +278  + #__USE_MISC + 1 + + ) + +281 #ifdef +_BSD_SOURCE + + +282  + #__USE_BSD + 1 + + ) + +285 #ifdef +_SVID_SOURCE + + +286  + #__USE_SVID + 1 + + ) + +289 #ifdef +_ATFILE_SOURCE + + +290  + #__USE_ATFILE + 1 + + ) + +293 #ifdef +_GNU_SOURCE + + +294  + #__USE_GNU + 1 + + ) + +297 #i +defed + +_REENTRANT + || defed +_THREAD_SAFE + + +298  + #__USE_REENTRANT + 1 + + ) + +301 #i +defed + +_FORTIFY_SOURCE + && _FORTIFY_SOURCE > 0 \ + +302 && +__GNUC_PREREQ + (4, 1&& +defed + + g__OPTIMIZE__ + && __OPTIMIZE__ > 0 + +303 #i +_FORTIFY_SOURCE + > 1 + +304  + #__USE_FORTIFY_LEVEL + 2 + + ) + +306  + #__USE_FORTIFY_LEVEL + 1 + + ) + +309  + #__USE_FORTIFY_LEVEL + 0 + + ) + +313  + ~ + +316  + #__STDC_ISO_10646__ + 200009L + + ) + +324 #unde +__GNU_LIBRARY__ + + +325  + #__GNU_LIBRARY__ + 6 + + ) + +329  + #__GLIBC__ + 2 + + ) + +330  + #__GLIBC_MINOR__ + 11 + + ) + +332  + #__GLIBC_PREREQ +( +maj +, +m +) \ + +333 (( +__GLIBC__ + << 16+ +__GLIBC_MINOR__ + >(( +maj +<< 16+ ( +m +)) + + ) + +336 #i +defed + +__GNUC__ + \ + +337 || ( +defed + + g__PGI + && defed + g__i386__ + ) \ + +338 || ( +defed + + g__INTEL_COMPILER + && (defed + g__i386__ + || defed + g__64__ +)) \ + +339 || ( +defed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L) + +340  + #__GLIBC_HAVE_LONG_LONG + 1 + + ) + +344 #ide +__ASSEMBLER__ + + +345 #ide +_SYS_CDEFS_H + + +346  + ~ + +351 #i +defed + +__USE_FILE_OFFSET64 + && !defed +__REDIRECT + + +352  + #__USE_LARGEFILE + 1 + + ) + +353  + #__USE_LARGEFILE64 + 1 + + ) + +359 #i +__GNUC_PREREQ + (2, 7&& +defed + +__OPTIMIZE__ + \ + +360 && ! +defed + + g__OPTIMIZE_SIZE__ + && !defed + g__NO_INLINE__ + \ + +361 && +defed + + g__ex_le + + +362  + #__USE_EXTERN_INLINES + 1 + + ) + +367 #i +__GNUC_PREREQ + (2, 7&& +defed + +__OPTIMIZE__ + \ + +368 && ( +defed + + g_LIBC + || !defed + g__OPTIMIZE_SIZE__ +&& !defed + g__NO_INLINE__ + \ + +369 && +defed + + g__ex_le + + +370  + #__USE_EXTERN_INLINES_IN_LIBC + 1 + + ) + +378  + ~ + + @/usr/include/getopt.h + +21 #ide +_GETOPT_H + + +23 #ide +__ed_gt + + +24  + #_GETOPT_H + 1 + + ) + +34 #i! +defed + +__GNU_LIBRARY__ + + +35  + ~ + +38 #ide +__THROW + + +39 #ide +__GNUC_PREREQ + + +40  + #__GNUC_PREREQ +( +maj +, +m +(0) + + ) + +42 #i +defed + +__lulus + && +__GNUC_PREREQ + (2,8) + +43  + #__THROW + + `throw + () + + ) + +45  + #__THROW + + + ) + +49 #ifdef +__lulus + + +59 * +ݏrg +; + +73  +td +; + +78  +݋ +; + +82  +tt +; + +84 #ide +__ed_gt + + +106  + sti + + +108 cڡ * + gme +; + +111  + ghas_g +; + +112 * + gag +; + +113  + gv +; + +118  + #no_gumt + 0 + + ) + +119  + #qued_gumt + 1 + + ) + +120  + #tiڮ_gumt + 2 + + ) + +148 #ifde +__GNU_LIBRARY__ + + +152  +gt + ( +___gc +, *cڡ * +___gv +, cڡ * +__shtts +) + +153 +__THROW +; + +155 #i +defed + +__ed_gt + && defed +__USE_POSIX2 + \ + +156 && ! +defed + + g__USE_POSIX_IMPLICITLY + && !defed + g__USE_GNU + + +160 #ifde +__REDIRECT + + +161  +__REDIRECT + ( +gt +, ( +___gc +, *cڡ * +___gv +, + +162 cڡ * +__shtts +), + +163 +__posix_gt + +__THROW +; + +165  +__posix_gt + ( +___gc +, *cڡ * +___gv +, + +166 cڡ * +__shtts + +__THROW +; + +167  + #gt + +__posix_gt + + + ) + +171  +gt + (); + +174 #ide +__ed_gt + + +175  +gt_lg + ( +___gc +, *cڡ * +___gv +, + +176 cڡ * +__shtts +, + +177 cڡ  +ti + * +__lgts +, * +__lgd +) + +178 +__THROW +; + +179  +gt_lg_ly + ( +___gc +, *cڡ * +___gv +, + +180 cڡ * +__shtts +, + +181 cڡ  +ti + * +__lgts +, * +__lgd +) + +182 +__THROW +; + +186 #ifdef +__lulus + + +191 #unde +__ed_gt + + + @/usr/include/libio.h + +29 #ide +_IO_STDIO_H + + +30  + #_IO_STDIO_H + + + ) + +32  + ~<_G_cfig.h +> + +34  + #_IO_pos_t + +_G_os_t + + + ) + +35  + #_IO_os_t + +_G_os_t + + + ) + +36  + #_IO_os64_t + +_G_os64_t + + + ) + +37  + #_IO_size_t + +_G_size_t + + + ) + +38  + #_IO_ssize_t + +_G_ssize_t + + + ) + +39  + #_IO_off_t + +_G_off_t + + + ) + +40  + #_IO_off64_t + +_G_off64_t + + + ) + +41  + #_IO_pid_t + +_G_pid_t + + + ) + +42  + #_IO_uid_t + +_G_uid_t + + + ) + +43  + #_IO_icv_t + +_G_icv_t + + + ) + +44  + #_IO_HAVE_SYS_WAIT + +_G_HAVE_SYS_WAIT + + + ) + +45  + #_IO_HAVE_ST_BLKSIZE + +_G_HAVE_ST_BLKSIZE + + + ) + +46  + #_IO_BUFSIZ + +_G_BUFSIZ + + + ) + +47  + #_IO_va_li + +_G_va_li + + + ) + +48  + #_IO_wt_t + +_G_wt_t + + + ) + +50 #ifde +_G_NEED_STDARG_H + + +52  + #__ed___va_li + + + ) + +53  + ~ + +54 #ifde +__GNUC_VA_LIST + + +55 #unde +_IO_va_li + + +56  + #_IO_va_li + +__gnuc_va_li + + + ) + +60 #ide +__P + + +61 #i +_G_HAVE_SYS_CDEFS + + +62  + ~ + +64 #ifde +__STDC__ + + +65  + #__P +( +p + + ) +p + +66  + #__PMT +( +p + + ) +p + +68  + #__P +( +p +() + + ) + +69  + #__PMT +( +p +() + + ) + +75 #ide +_PARAMS + + +76  + #_PARAMS +( +os + + `__P +ros) + + ) + +79 #ide +__STDC__ + + +81 cڡ + + ) + +84  + #_IO_UNIFIED_JUMPTABLES + 1 + + ) + +85 #ide +_G_HAVE_PRINTF_FP + + +86  + #_IO_USE_DTOA + 1 + + ) + +89 #ide +EOF + + +90  + #EOF + (-1) + + ) + +92 #ide +NULL + + +93 #i +defed + +__GNUG__ + && \ + +94 ( + g__GNUC__ + > 2 || (__GNUC__ =2 && +__GNUC_MINOR__ + >= 8)) + +95  + #NULL + ( +__nu +) + + ) + +97 #i! +defed +( +__lulus +) + +98  + #NULL + ((*)0) + + ) + +100  + #NULL + (0) + + ) + +105  + #_IOS_INPUT + 1 + + ) + +106  + #_IOS_OUTPUT + 2 + + ) + +107  + #_IOS_ATEND + 4 + + ) + +108  + #_IOS_APPEND + 8 + + ) + +109  + #_IOS_TRUNC + 16 + + ) + +110  + #_IOS_NOCREATE + 32 + + ) + +111  + #_IOS_NOREPLACE + 64 + + ) + +112  + #_IOS_BIN + 128 + + ) + +120  + #_IO_MAGIC + 0xFBAD0000 + + ) + +121  + #_OLD_STDIO_MAGIC + 0xFABC0000 + + ) + +122  + #_IO_MAGIC_MASK + 0xFFFF0000 + + ) + +123  + #_IO_USER_BUF + 1 + + ) + +124  + #_IO_UNBUFFERED + 2 + + ) + +125  + #_IO_NO_READS + 4 + + ) + +126  + #_IO_NO_WRITES + 8 + + ) + +127  + #_IO_EOF_SEEN + 0x10 + + ) + +128  + #_IO_ERR_SEEN + 0x20 + + ) + +129  + #_IO_DELETE_DONT_CLOSE + 0x40 + + ) + +130  + #_IO_LINKED + 0x80 + + ) + +131  + #_IO_IN_BACKUP + 0x100 + + ) + +132  + #_IO_LINE_BUF + 0x200 + + ) + +133  + #_IO_TIED_PUT_GET + 0x400 + + ) + +134  + #_IO_CURRENTLY_PUTTING + 0x800 + + ) + +135  + #_IO_IS_APPENDING + 0x1000 + + ) + +136  + #_IO_IS_FILEBUF + 0x2000 + + ) + +137  + #_IO_BAD_SEEN + 0x4000 + + ) + +138  + #_IO_USER_LOCK + 0x8000 + + ) + +140  + #_IO_FLAGS2_MMAP + 1 + + ) + +141  + #_IO_FLAGS2_NOTCANCEL + 2 + + ) + +142 #ifde +_LIBC + + +143  + #_IO_FLAGS2_FORTIFY + 4 + + ) + +145  + #_IO_FLAGS2_USER_WBUF + 8 + + ) + +146 #ifde +_LIBC + + +147  + #_IO_FLAGS2_SCANF_STD + 16 + + ) + +151  + #_IO_SKIPWS + 01 + + ) + +152  + #_IO_LEFT + 02 + + ) + +153  + #_IO_RIGHT + 04 + + ) + +154  + #_IO_INTERNAL + 010 + + ) + +155  + #_IO_DEC + 020 + + ) + +156  + #_IO_OCT + 040 + + ) + +157  + #_IO_HEX + 0100 + + ) + +158  + #_IO_SHOWBASE + 0200 + + ) + +159  + #_IO_SHOWPOINT + 0400 + + ) + +160  + #_IO_UPPERCASE + 01000 + + ) + +161  + #_IO_SHOWPOS + 02000 + + ) + +162  + #_IO_SCIENTIFIC + 04000 + + ) + +163  + #_IO_FIXED + 010000 + + ) + +164  + #_IO_UNITBUF + 020000 + + ) + +165  + #_IO_STDIO + 040000 + + ) + +166  + #_IO_DONT_CLOSE + 0100000 + + ) + +167  + #_IO_BOOLALPHA + 0200000 + + ) + +170  +_IO_jump_t +;  + g_IO_FILE +; + +173 #ifde +_IO_MTSAFE_IO + + +174 #i +defed + +__GLIBC__ + && __GLIBC__ >= 2 + +175  + ~ + +180  + t_IO_lock_t +; + +186  + s_IO_mk + { + +187  +_IO_mk + * + m_xt +; + +188  +_IO_FILE + * + m_sbuf +; + +192  + m_pos +; + +194  +t_ampos +( +ampos + + +{ + m_os + = sp; } + +195  +t_offt +( +offt +{ + m_pos + = offt; + m_os + = ( +ampos +)(-2); } + +196 + mpublic +: + +197 +ammk +( +ambuf + * +sb +); + +198 ~ +ammk +(); + +199  +vg +({  + m_os + == -2; } + +200  +d +( +ammk +&); + +201  +d +(); + +206 + e__codecvt_su + + +208 + m__codecvt_ok +, + +209 + m__codecvt_l +, + +210 + m__codecvt_r +, + +211 + m__codecvt_nocv + + +214 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +217  + s_IO_codecvt + + +219 (* + m__codecvt_der +( + m_IO_codecvt + *); + +220 +__codecvt_su + (* +__codecvt_do_out +( + m_IO_codecvt + *, + +221 + m__mbe_t + *, + +222 cڡ + mwch_t + *, + +223 cڡ + mwch_t + *, + +224 cڡ + mwch_t + **, *, + +226 +__codecvt_su + (* +__codecvt_do_unshi +( + m_IO_codecvt + *, + +227 + m__mbe_t + *, *, + +229 +__codecvt_su + (* +__codecvt_do_ +( + m_IO_codecvt + *, + +230 + m__mbe_t + *, + +232 cڡ **, + mwch_t + *, + +233 + mwch_t + *, wchar_t **); + +234 (* + m__codecvt_do_codg +( + m_IO_codecvt + *); + +235 (* + m__codecvt_do_ways_nocv +( + m_IO_codecvt + *); + +236 (* + m__codecvt_do_ngth +( + m_IO_codecvt + *, + m__mbe_t + *, + +237 cڡ *, cڡ *, + m_IO_size_t +); + +238 (* + m__codecvt_do_max_ngth +( + m_IO_codecvt + *); + +240 +_IO_icv_t + + m__cd_ +; + +241 +_IO_icv_t + + m__cd_out +; + +245  + s_IO_wide_da + + +247 +wch_t + * + m_IO_ad_r +; + +248 +wch_t + * + m_IO_ad_d +; + +249 +wch_t + * + m_IO_ad_ba +; + +250 +wch_t + * + m_IO_wre_ba +; + +251 +wch_t + * + m_IO_wre_r +; + +252 +wch_t + * + m_IO_wre_d +; + +253 +wch_t + * + m_IO_buf_ba +; + +254 +wch_t + * + m_IO_buf_d +; + +256 +wch_t + * + m_IO_ve_ba +; + +257 +wch_t + * + m_IO_backup_ba +; + +259 +wch_t + * + m_IO_ve_d +; + +261 +__mbe_t + + m_IO_e +; + +262 +__mbe_t + + m_IO_ϡ_e +; + +263  +_IO_codecvt + + m_codecvt +; + +265 +wch_t + + m_shtbuf +[1]; + +267 cڡ  +_IO_jump_t + * + m_wide_vb +; + +271  + s_IO_FILE + { + +272  + m_ags +; + +273  + #_IO_fe_ags + +_ags + + + ) + +277 * + m_IO_ad_r +; + +278 * + m_IO_ad_d +; + +279 * + m_IO_ad_ba +; + +280 * + m_IO_wre_ba +; + +281 * + m_IO_wre_r +; + +282 * + m_IO_wre_d +; + +283 * + m_IO_buf_ba +; + +284 * + m_IO_buf_d +; + +286 * + m_IO_ve_ba +; + +287 * + m_IO_backup_ba +; + +288 * + m_IO_ve_d +; + +290  +_IO_mk + * + m_mks +; + +292  +_IO_FILE + * + m_cha +; + +294  + m_fo +; + +296  + m_blksize +; + +298  + m_ags2 +; + +300 +_IO_off_t + + m_d_offt +; + +302  + #__HAVE_COLUMN + + + ) + +304  + m_cur_cumn +; + +305 sigd  + m_vb_offt +; + +306  + m_shtbuf +[1]; + +310 +_IO_lock_t + * + m_lock +; + +311 #ifde +_IO_USE_OLD_IO_FILE + + +314  + s_IO_FILE_come + + +316  +_IO_FILE + + m_fe +; + +318 #i +defed + +_G_IO_IO_FILE_VERSION + && _G_IO_IO_FILE_VERSION == 0x20001 + +319 +_IO_off64_t + + m_offt +; + +320 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +322  +_IO_codecvt + * + m_codecvt +; + +323  +_IO_wide_da + * + m_wide_da +; + +324  +_IO_FILE + * + m_䓻s_li +; + +325 * + m_䓻s_buf +; + +326 +size_t + + m_䓻s_size +; + +328 * + m__d1 +; + +329 * + m__d2 +; + +330 * + m__d3 +; + +331 * + m__d4 +; + +332 +size_t + + m__d5 +; + +334  + m_mode +; + +336  + m_unud2 +[15 *  (- 4 *  (*-  ( +size_t +)]; + +340 #ide +__lulus + + +341  +_IO_FILE + + t_IO_FILE +; + +344  + g_IO_FILE_us +; + +346  +_IO_FILE_us + +_IO_2_1_d_ +; + +347  +_IO_FILE_us + +_IO_2_1_dout_ +; + +348  +_IO_FILE_us + +_IO_2_1_dr_ +; + +349 #ide +_LIBC + + +350  + #_IO_d + (( +_IO_FILE +*)(& +_IO_2_1_d_ +)) + + ) + +351  + #_IO_dout + (( +_IO_FILE +*)(& +_IO_2_1_dout_ +)) + + ) + +352  + #_IO_dr + (( +_IO_FILE +*)(& +_IO_2_1_dr_ +)) + + ) + +354 +_IO_FILE + * +_IO_d + +ibu_hidd +; + +355 +_IO_FILE + * +_IO_dout + +ibu_hidd +; + +356 +_IO_FILE + * +_IO_dr + +ibu_hidd +; + +364  +__ssize_t + + t__io_ad_ + (* + t__cook +, * + t__buf +, + tsize_t + + t__nbys +); + +372  +__ssize_t + + t__io_wre_ + (* + t__cook +, + t__cڡ + * + t__buf +, + +373 + tsize_t + + t__n +); + +381  + t__io_ek_ + (* + t__cook +, + t_IO_off64_t + * + t__pos +,  + t__w +); + +384  + t__io_o_ + (* + t__cook +); + +387 #ifde +_GNU_SOURCE + + +389  +__io_ad_ + + tcook_ad_funi_t +; + +390  +__io_wre_ + + tcook_wre_funi_t +; + +391  +__io_ek_ + + tcook_ek_funi_t +; + +392  +__io_o_ + + tcook_o_funi_t +; + +397 +__io_ad_ + * + mad +; + +398 +__io_wre_ + * + mwre +; + +399 +__io_ek_ + * + mek +; + +400 +__io_o_ + * + mo +; + +401 } + t_IO_cook_io_funis_t +; + +402  +_IO_cook_io_funis_t + + tcook_io_funis_t +; + +404  + g_IO_cook_fe +; + +407  +_IO_cook_ + ( +_IO_cook_fe + * +__cfe +,  +__ad_wre +, + +408 * +__cook +, +_IO_cook_io_funis_t + +__s +); + +412 #ifde +__lulus + + +416  +__undow + ( +_IO_FILE + *); + +417  +__uow + ( +_IO_FILE + *); + +418  +__ovow + ( +_IO_FILE + *, ); + +419 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +420 +_IO_wt_t + +__wundow + ( +_IO_FILE + *); + +421 +_IO_wt_t + +__wuow + ( +_IO_FILE + *); + +422 +_IO_wt_t + +__wovow + ( +_IO_FILE + *, _IO_wint_t); + +425 #i +__GNUC__ + >= 3 + +426  + #_IO_BE +( +ex +, +s + + `__but_ex + (x),es) + + ) + +428  + #_IO_BE +( +ex +, +s +x) + + ) + +431  + #_IO_gc_uocked +( +_ +) \ + +432 ( + `_IO_BE + (( +_ +)-> +_IO_ad_r + >(_)-> +_IO_ad_d +, 0) \ + +433 ? + `__uow + ( +_ +: *(*(_)-> +_IO_ad_r +++) + + ) + +434  + #_IO_ekc_uocked +( +_ +) \ + +435 ( + `_IO_BE + (( +_ +)-> +_IO_ad_r + >(_)-> +_IO_ad_d +, 0) \ + +436 && + `__undow + ( +_ += +EOF + ? EOF \ + +437 : *(*( +_ +)-> +_IO_ad_r +) + + ) + +438  + #_IO_putc_uocked +( +_ch +, +_ +) \ + +439 ( + `_IO_BE + (( +_ +)-> +_IO_wre_r + >(_)-> +_IO_wre_d +, 0) \ + +440 ? + `__ovow + ( +_ +, (( +_ch +)) \ + +441 : ((*( +_ +)-> +_IO_wre_r +++ = ( +_ch +))) + + ) + +443 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +444  + #_IO_gwc_uocked +( +_ +) \ + +445 ( + `_IO_BE + (( +_ +)-> +_wide_da + = +NULL + \ + +446 || (( +_ +)-> +_wide_da +-> +_IO_ad_r + \ + +447 >( +_ +)-> +_wide_da +-> +_IO_ad_d +), 0) \ + +448 ? + `__wuow + ( +_ +: ( +_IO_wt_t +*(_)-> +_wide_da +-> +_IO_ad_r +++) + + ) + +449  + #_IO_putwc_uocked +( +_wch +, +_ +) \ + +450 ( + `_IO_BE + (( +_ +)-> +_wide_da + = +NULL + \ + +451 || (( +_ +)-> +_wide_da +-> +_IO_wre_r + \ + +452 >( +_ +)-> +_wide_da +-> +_IO_wre_d +), 0) \ + +453 ? + `__wovow + ( +_ +, +_wch +) \ + +454 : ( +_IO_wt_t +(*( +_ +)-> +_wide_da +-> +_IO_wre_r +++ = ( +_wch +))) + + ) + +457  + #_IO_of_uocked +( +__ +(((__)-> +_ags + & +_IO_EOF_SEEN +!0) + + ) + +458  + #_IO__uocked +( +__ +(((__)-> +_ags + & +_IO_ERR_SEEN +!0) + + ) + +460  +_IO_gc + ( +_IO_FILE + * +__ +); + +461  +_IO_putc + ( +__c +, +_IO_FILE + * +__ +); + +462  +_IO_of + ( +_IO_FILE + * +__ + +__THROW +; + +463  +_IO_ + ( +_IO_FILE + * +__ + +__THROW +; + +465  +_IO_ekc_locked + ( +_IO_FILE + * +__ +); + +468  + #_IO_PENDING_OUTPUT_COUNT +( +_ +) \ + +469 (( +_ +)-> +_IO_wre_r + - (_)-> +_IO_wre_ba +) + + ) + +471  +_IO_ockfe + ( +_IO_FILE + * +__THROW +; + +472  +_IO_fuockfe + ( +_IO_FILE + * +__THROW +; + +473  +_IO_rylockfe + ( +_IO_FILE + * +__THROW +; + +475 #ifde +_IO_MTSAFE_IO + + +476  + #_IO_ekc +( +_ + + `_IO_ekc_locked + (_) + + ) + +477  + #_IO_ockfe +( +_ +) \ + +478 i((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0 + `_IO_ockfe + (_) + + ) + +479  + #_IO_fuockfe +( +_ +) \ + +480 i((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0 + `_IO_fuockfe + (_) + + ) + +482  + #_IO_ekc +( +_ + + `_IO_ekc_uocked + (_) + + ) + +483  + #_IO_ockfe +( +_ + + + ) + +484  + #_IO_fuockfe +( +_ + + + ) + +485  + #_IO_rylockfe +( +_ + + + ) + +486  + #_IO_nup_gi_t +( +_f +, +_ + + + ) + +487  + #_IO_nup_gi_d +( +_Do + + + ) + +490  +_IO_vfsnf + ( +_IO_FILE + * +__ri +, const * __restrict, + +491 +_IO_va_li +, * +__ri +); + +492  +_IO_vrtf + ( +_IO_FILE + * +__ri +, const *__restrict, + +493 +_IO_va_li +); + +494 +_IO_ssize_t + +_IO_dn + ( +_IO_FILE + *, , _IO_ssize_t); + +495 +_IO_size_t + +_IO_sgn + ( +_IO_FILE + *, *, _IO_size_t); + +497 +_IO_off64_t + +_IO_ekoff + ( +_IO_FILE + *, _IO_off64_t, , ); + +498 +_IO_off64_t + +_IO_ekpos + ( +_IO_FILE + *, _IO_off64_t, ); + +500  +_IO__backup_ + ( +_IO_FILE + * +__THROW +; + +502 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +503 +_IO_wt_t + +_IO_gwc + ( +_IO_FILE + * +__ +); + +504 +_IO_wt_t + +_IO_putwc + ( +wch_t + +__wc +, +_IO_FILE + * +__ +); + +505  +_IO_fwide + ( +_IO_FILE + * +__ +,  +__mode + +__THROW +; + +506 #i +__GNUC__ + >= 2 + +509 #i +defed + +_LIBC + && defed +SHARED + + +510  + ~ + +511 #i +SHLIB_COMPAT + ( +libc +, +GLIBC_2_0 +, +GLIBC_2_1 +) + +512  + #_IO_fwide_maybe_comtib + \ + +513 ( + `__but_ex + (& +_IO_d_ud + = +NULL +, 0)) + + ) + +514 cڡ  +_IO_d_ud +; + +515 +wk_ex + ( +_IO_d_ud +); + +518 #ide +_IO_fwide_maybe_comtib + + +519  + #_IO_fwide_maybe_comtib + (0) + + ) + +523  + #_IO_fwide +( +__ +, +__mode +) \ + +524 ({  +__su + = ( +__mode +); \ + +525 i( +__su + < 0 && ! +_IO_fwide_maybe_comtib +) \ + +527 i(( +__ +)-> +_mode + == 0) \ + +529 ( +__ +)-> +_mode + = -1; \ + +530 +__su + = ( +__ +)-> +_mode +; \ + +532 i( + `__but_cڡt_p + ( +__mode +) && (__mode) == 0) \ + +533 +__su + = +_IO_fwide_maybe_comtib + ? -1 : ( +__ +)-> +_mode +; \ + +535 +__su + = + `_IO_fwide + ( +__ +, __result); \ + +536 +__su +; }) + + ) + +539  +_IO_vfwsnf + ( +_IO_FILE + * +__ri +, cڡ +wch_t + * __restrict, + +540 +_IO_va_li +, * +__ri +); + +541  +_IO_vfwtf + ( +_IO_FILE + * +__ri +, cڡ +wch_t + *__restrict, + +542 +_IO_va_li +); + +543 +_IO_ssize_t + +_IO_wdn + ( +_IO_FILE + *, +wt_t +, _IO_ssize_t); + +544  +_IO__wbackup_ + ( +_IO_FILE + * +__THROW +; + +547 #ifde +__LDBL_COMPAT + + +548  + ~ + +551 #ifde +__lulus + + + @/usr/include/_G_config.h + +4 #ide +_G_cfig_h + + +5  + #_G_cfig_h + 1 + + ) + +9  + ~ + +10  + #__ed_size_t + + + ) + +11 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +12  + #__ed_wch_t + + + ) + +14  + #__ed_NULL + + + ) + +15  + ~ + +16  + #__ed_mbe_t + + + ) + +17 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +18  + #__ed_wt_t + + + ) + +20  + ~ + +21  + #_G_size_t + +size_t + + + ) + +24 +__off_t + + m__pos +; + +25 +__mbe_t + + m__e +; + +26 } + t_G_os_t +; + +29 +__off64_t + + m__pos +; + +30 +__mbe_t + + m__e +; + +31 } + t_G_os64_t +; + +32  + #_G_ssize_t + +__ssize_t + + + ) + +33  + #_G_off_t + +__off_t + + + ) + +34  + #_G_off64_t + +__off64_t + + + ) + +35  + #_G_pid_t + +__pid_t + + + ) + +36  + #_G_uid_t + +__uid_t + + + ) + +37  + #_G_wch_t + +wch_t + + + ) + +38  + #_G_wt_t + +wt_t + + + ) + +39  + #_G_64 + +64 + + + ) + +40 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +41  + ~ + +44  +__gcv_fo + + m__cd +; + +47  +__gcv_fo + + m__cd +; + +48  +__gcv__da + + m__da +; + +49 } + m__combed +; + +50 } + t_G_icv_t +; + +53  + t_G_t16_t + + t__ibu__ + (( + t__mode__ + ( + t__HI__ +))); + +54  + t_G_t32_t + + t__ibu__ + (( + t__mode__ + ( + t__SI__ +))); + +55  + t_G_ut16_t + + t__ibu__ + (( + t__mode__ + ( + t__HI__ +))); + +56  + t_G_ut32_t + + t__ibu__ + (( + t__mode__ + ( + t__SI__ +))); + +58  + #_G_HAVE_BOOL + 1 + + ) + +62  + #_G_HAVE_ATEXIT + 1 + + ) + +63  + #_G_HAVE_SYS_CDEFS + 1 + + ) + +64  + #_G_HAVE_SYS_WAIT + 1 + + ) + +65  + #_G_NEED_STDARG_H + 1 + + ) + +66  + #_G_va_li + +__gnuc_va_li + + + ) + +68  + #_G_HAVE_PRINTF_FP + 1 + + ) + +69  + #_G_HAVE_MMAP + 1 + + ) + +70  + #_G_HAVE_MREMAP + 1 + + ) + +71  + #_G_HAVE_LONG_DOUBLE_IO + 1 + + ) + +72  + #_G_HAVE_IO_FILE_OPEN + 1 + + ) + +73  + #_G_HAVE_IO_GETLINE_INFO + 1 + + ) + +75  + #_G_IO_IO_FILE_VERSION + 0x20001 + + ) + +77  + #_G_OPEN64 + +__ݒ64 + + + ) + +78  + #_G_LSEEK64 + +__lek64 + + + ) + +79  + #_G_MMAP64 + +__mm64 + + + ) + +80  + #_G_FSTAT64 +( +fd +, +buf + + `__fx64 + ( +_STAT_VER +, fd, buf) + + ) + +83  + #_G_HAVE_ST_BLKSIZE + + `defed + ( +_STATBUF_ST_BLKSIZE +) + + ) + +85  + #_G_BUFSIZ + 8192 + + ) + +88  + #_G_NAMES_HAVE_UNDERSCORE + 0 + + ) + +89  + #_G_VTABLE_LABEL_HAS_LENGTH + 1 + + ) + +90  + #_G_USING_THUNKS + 1 + + ) + +91  + #_G_VTABLE_LABEL_PREFIX + "__vt_" + + ) + +92  + #_G_VTABLE_LABEL_PREFIX_ID + +__vt_ + + + ) + +95 #i +defed + +__lulus + || defed +__STDC__ + + +96  + #_G_ARGS +( +ARGLIST + + ) +ARGLIST + +98  + #_G_ARGS +( +ARGLIST +() + + ) + + @/usr/include/bits/libio-ldbl.h + +20 #ide +_IO_STDIO_H + + +24 + $__LDBL_REDIR_DECL + ( +_IO_vfsnf +) + +25 + `__LDBL_REDIR_DECL + ( +_IO_vrtf +) + + @/usr/include/bits/predefs.h + +19 #ide +_FEATURES_H + + +23 #ide +_PREDEFS_H + + +24  + #_PREDEFS_H + + + ) + +27  + #__STDC_IEC_559__ + 1 + + ) + +28  + #__STDC_IEC_559_COMPLEX__ + 1 + + ) + + @/usr/include/bits/stdio-lock.h + +20 #ide +_BITS_STDIO_LOCK_H + + +21  + #_BITS_STDIO_LOCK_H + 1 + + ) + +23  + ~ + +24  + ~ + +28  + #_IO_lock_exnsive + 1 + + ) + +30 ru {  + mlock +;  + mt +; * + mowr +; } + t_IO_lock_t +; + +32  + #_IO_lock_liz + { +LLL_LOCK_INITIALIZER +, 0, +NULL + } + + ) + +34  + #_IO_lock_ +( +_me +) \ + +35 (( +_me +( +_IO_lock_t + +_IO_lock_liz + , 0) + + ) + +37  + #_IO_lock_fi +( +_me +) \ + +38 ((0) + + ) + +40  + #_IO_lock_lock +( +_me +) \ + +42 * +__lf + = +THREAD_SELF +; \ + +43 i(( +_me +). +owr + ! +__lf +) \ + +45 + `l_lock + (( +_me +). +lock +, +LLL_PRIVATE +); \ + +46 ( +_me +). +owr + = +__lf +; \ + +48 ++( +_me +). +t +; \ + +49 } 0) + + ) + +51  + #_IO_lock_ylock +( +_me +) \ + +53  +__su + = 0; \ + +54 * +__lf + = +THREAD_SELF +; \ + +55 i(( +_me +). +owr + ! +__lf +) \ + +57 i( + `l_ylock + (( +_me +). +lock +) == 0) \ + +59 ( +_me +). +owr + = +__lf +; \ + +60 ( +_me +). +t + = 1; \ + +63 +__su + = +EBUSY +; \ + +66 ++( +_me +). +t +; \ + +67 +__su +; \ + +68 }) + + ) + +70  + #_IO_lock_uock +( +_me +) \ + +72 i(--( +_me +). +t + == 0) \ + +74 ( +_me +). +owr + = +NULL +; \ + +75 + `l_uock + (( +_me +). +lock +, +LLL_PRIVATE +); \ + +77 } 0) + + ) + +81  + #_IO_nup_gi_t +( +_f +, +_ +) \ + +82 + `__libc_nup_gi_t + ((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0, +_f +, _) + + ) + +83  + #_IO_nup_gi_t_nrg +( +_f +) \ + +84 + `__libc_nup_gi_t + (1, +_f +, +NULL +) + + ) + +85  + #_IO_nup_gi_d +( +_do +) \ + +86 + `__libc_nup_gi_d + ( +_do +) + + ) + +88 #i +defed + +_LIBC + && !defed +NOT_IN_libc + + +90 #ifde +__EXCEPTIONS + + +91  + #_IO_acque_lock +( +_ +) \ + +93 +_IO_FILE + * +_IO_acque_lock_fe + \ + +94 + `__ibu__ +(( + `nup + ( +_IO_acque_lock_f +))) \ + +95 ( +_ +); \ + +96 + `_IO_ockfe + ( +_IO_acque_lock_fe +); + + ) + +97  + #_IO_acque_lock_r_ags2 +( +_ +) \ + +99 +_IO_FILE + * +_IO_acque_lock_fe + \ + +100 + `__ibu__ +(( + `nup + ( +_IO_acque_lock_r_ags2_f +))) \ + +101 ( +_ +); \ + +102 + `_IO_ockfe + ( +_IO_acque_lock_fe +); + + ) + +104  + #_IO_acque_lock +( +_ + +_IO_acque_lock_eds_exis_abd + + + ) + +105  + #_IO_acque_lock_r_ags2 +( +_ + + `_IO_acque_lock + (_) + + ) + +107  + #_IO_a_lock +( +_ +; } 0) + + ) + + @/usr/include/bits/typesizes.h + +20 #ide +_BITS_TYPES_H + + +24 #idef +_BITS_TYPESIZES_H + + +25  + #_BITS_TYPESIZES_H + 1 + + ) + +30  + #__DEV_T_TYPE + +__UQUAD_TYPE + + + ) + +31  + #__UID_T_TYPE + +__U32_TYPE + + + ) + +32  + #__GID_T_TYPE + +__U32_TYPE + + + ) + +33  + #__INO_T_TYPE + +__ULONGWORD_TYPE + + + ) + +34  + #__INO64_T_TYPE + +__UQUAD_TYPE + + + ) + +35  + #__MODE_T_TYPE + +__U32_TYPE + + + ) + +36  + #__NLINK_T_TYPE + +__UWORD_TYPE + + + ) + +37  + #__OFF_T_TYPE + +__SLONGWORD_TYPE + + + ) + +38  + #__OFF64_T_TYPE + +__SQUAD_TYPE + + + ) + +39  + #__PID_T_TYPE + +__S32_TYPE + + + ) + +40  + #__RLIM_T_TYPE + +__ULONGWORD_TYPE + + + ) + +41  + #__RLIM64_T_TYPE + +__UQUAD_TYPE + + + ) + +42  + #__BLKCNT_T_TYPE + +__SLONGWORD_TYPE + + + ) + +43  + #__BLKCNT64_T_TYPE + +__SQUAD_TYPE + + + ) + +44  + #__FSBLKCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +45  + #__FSBLKCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +46  + #__FSFILCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +47  + #__FSFILCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +48  + #__ID_T_TYPE + +__U32_TYPE + + + ) + +49  + #__CLOCK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +50  + #__TIME_T_TYPE + +__SLONGWORD_TYPE + + + ) + +51  + #__USECONDS_T_TYPE + +__U32_TYPE + + + ) + +52  + #__SUSECONDS_T_TYPE + +__SLONGWORD_TYPE + + + ) + +53  + #__DADDR_T_TYPE + +__S32_TYPE + + + ) + +54  + #__SWBLK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +55  + #__KEY_T_TYPE + +__S32_TYPE + + + ) + +56  + #__CLOCKID_T_TYPE + +__S32_TYPE + + + ) + +57  + #__TIMER_T_TYPE + * + + ) + +58  + #__BLKSIZE_T_TYPE + +__SLONGWORD_TYPE + + + ) + +59  + #__FSID_T_TYPE + su {  +__v +[2]; } + + ) + +60  + #__SSIZE_T_TYPE + +__SWORD_TYPE + + + ) + +63  + #__FD_SETSIZE + 1024 + + ) + + @/usr/include/bits/wordsize.h + +3 #i +defed + +__x86_64__ + + +4  + #__WORDSIZE + 64 + + ) + +5  + #__WORDSIZE_COMPAT32 + 1 + + ) + +7  + #__WORDSIZE + 32 + + ) + + @/usr/include/ctype.h + +24 #idef +_CTYPE_H + + +25  + #_CTYPE_H + 1 + + ) + +27  + ~ + +28  + ~ + +30 + g__BEGIN_DECLS + + +32 #ide +_ISb + + +41  + ~ + +42 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +43  + #_ISb +( +b +(1 << (b)) + + ) + +45  + #_ISb +( +b +((b< 8 ? ((1 << (b)<< 8: ((1 << (b)>> 8)) + + ) + +50 + m_ISu + = +_ISb + (0), + +51 + m_ISlow + = +_ISb + (1), + +52 + m_ISpha + = +_ISb + (2), + +53 + m_ISdig + = +_ISb + (3), + +54 + m_ISxdig + = +_ISb + (4), + +55 + m_ISa + = +_ISb + (5), + +56 + m_ISt + = +_ISb + (6), + +57 + m_ISgph + = +_ISb + (7), + +58 + m_ISbnk + = +_ISb + (8), + +59 + m_ISl + = +_ISb + (9), + +60 + m_ISpun + = +_ISb + (10), + +61 + m_ISnum + = +_ISb + (11) + +81 +__cڡ + ** + $__y_b_loc + () + +82 +__THROW + + `__ibu__ + (( +__cڡ +)); + +83 +__cڡ + +__t32_t + ** + $__y_tow_loc + () + +84 +__THROW + + `__ibu__ + (( +__cڡ +)); + +85 +__cڡ + +__t32_t + ** + $__y_tou_loc + () + +86 +__THROW + + `__ibu__ + (( +__cڡ +)); + +88  + #__isy +( +c +, +ty +) \ + +89 ((* + `__y_b_loc + ())[(( +c +)] & ( +ty +) + + ) + +91  + #__iscii +( +c +(((c& ~0x7f=0 + + ) + +92  + #__tscii +( +c +((c& 0x7f + + ) + +94  + #__exy +( +me +  + `me + ( +__THROW + + + ) + +96 +__BEGIN_NAMESPACE_STD + + +102 + `__exy + ( +ium +); + +103 + `__exy + ( +iha +); + +104 + `__exy + ( +isl +); + +105 + `__exy + ( +isdig +); + +106 + `__exy + ( +iow +); + +107 + `__exy + ( +isgph +); + +108 + `__exy + ( +irt +); + +109 + `__exy + ( +iun +); + +110 + `__exy + ( +isa +); + +111 + `__exy + ( +isu +); + +112 + `__exy + ( +isxdig +); + +116  + $tow + ( +__c + +__THROW +; + +119  + $tou + ( +__c + +__THROW +; + +121 +__END_NAMESPACE_STD + + +125 #ifdef +__USE_ISOC99 + + +126 +__BEGIN_NAMESPACE_C99 + + +128 + `__exy + ( +isbnk +); + +130 +__END_NAMESPACE_C99 + + +133 #ifde +__USE_GNU + + +135  + $isy + ( +__c +,  +__mask + +__THROW +; + +138 #i +defed + +__USE_SVID + || defed +__USE_MISC + || defed +__USE_XOPEN + + +142  + $iscii + ( +__c + +__THROW +; + +146  + $tscii + ( +__c + +__THROW +; + +150 + `__exy + ( +_tou +); + +151 + `__exy + ( +_tow +); + +155  + #__tobody +( +c +, +f +, +a +, +gs +) \ + +156 ( +__exnsi__ + \ + +157 ({  +__s +; \ + +158 i( ( +c +) > 1) \ + +160 i( + `__but_cڡt_p + ( +c +)) \ + +162  +__c + = ( +c +); \ + +163 +__s + = +__c + < -128 || __> 255 ? __: ( +a +)[__c]; \ + +166 +__s + = +f + +gs +; \ + +169 +__s + = ( +a +)[(( +c +)]; \ + +170 +__s +; + } +})) + + ) + +172 #i! +defed + +__NO_CTYPE + && !defed +__lulus + + +173  + #ium +( +c + + `__isy +((c), +_ISnum +) + + ) + +174  + #iha +( +c + + `__isy +((c), +_ISpha +) + + ) + +175  + #isl +( +c + + `__isy +((c), +_ISl +) + + ) + +176  + #isdig +( +c + + `__isy +((c), +_ISdig +) + + ) + +177  + #iow +( +c + + `__isy +((c), +_ISlow +) + + ) + +178  + #isgph +( +c + + `__isy +((c), +_ISgph +) + + ) + +179  + #irt +( +c + + `__isy +((c), +_ISt +) + + ) + +180  + #iun +( +c + + `__isy +((c), +_ISpun +) + + ) + +181  + #isa +( +c + + `__isy +((c), +_ISa +) + + ) + +182  + #isu +( +c + + `__isy +((c), +_ISu +) + + ) + +183  + #isxdig +( +c + + `__isy +((c), +_ISxdig +) + + ) + +185 #ifde +__USE_ISOC99 + + +186  + #isbnk +( +c + + `__isy +((c), +_ISbnk +) + + ) + +189 #ifde +__USE_EXTERN_INLINES + + +190 +__ex_le +  + +191 +__NTH + ( + $tow + ( +__c +)) + +193  +__c + >-128 && __< 256 ? (* + `__y_tow_loc + ())[__c] : __c; + +194 + } +} + +196 +__ex_le +  + +197 +__NTH + ( + $tou + ( +__c +)) + +199  +__c + >-128 && __< 256 ? (* + `__y_tou_loc + ())[__c] : __c; + +200 + } +} + +203 #i +__GNUC__ + >2 && +defed + +__OPTIMIZE__ + && !defed +__lulus + + +204  + #tow +( +c + + `__tobody + (c, +tow +, * + `__y_tow_loc + (), (c)) + + ) + +205  + #tou +( +c + + `__tobody + (c, +tou +, * + `__y_tou_loc + (), (c)) + + ) + +208 #i +defed + +__USE_SVID + || defed +__USE_MISC + || defed +__USE_XOPEN + + +209  + #iscii +( +c + + `__iscii + (c) + + ) + +210  + #tscii +( +c + + `__tscii + (c) + + ) + +212  + #_tow +( +c +(((* + `__y_tow_loc + ())[((c)]) + + ) + +213  + #_tou +( +c +(((* + `__y_tou_loc + ())[((c)]) + + ) + +219 #ifde +__USE_XOPEN2K8 + + +233  + ~ + +237  + #__isy_l +( +c +, +ty +, +lo +) \ + +238 (( +lo +)-> +__y_b +[(( +c +)] & ( +ty +) + + ) + +240  + #__exy_l +( +me +) \ + +241  + `me + (, +__lo_t + +__THROW + + + ) + +247 +__exy_l + ( +ium_l +); + +248 +__exy_l + ( +iha_l +); + +249 +__exy_l + ( +isl_l +); + +250 +__exy_l + ( +isdig_l +); + +251 +__exy_l + ( +iow_l +); + +252 +__exy_l + ( +isgph_l +); + +253 +__exy_l + ( +irt_l +); + +254 +__exy_l + ( +iun_l +); + +255 +__exy_l + ( +isa_l +); + +256 +__exy_l + ( +isu_l +); + +257 +__exy_l + ( +isxdig_l +); + +259 +__exy_l + ( +isbnk_l +); + +263  + $__tow_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +264  + $tow_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +267  + $__tou_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +268  + $tou_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +270 #i +__GNUC__ + >2 && +defed + +__OPTIMIZE__ + && !defed +__lulus + + +271  + #__tow_l +( +c +, +lo +) \ + +272 + `__tobody + ( +c +, +__tow_l +, ( +lo +)-> +__y_tow +, (c,o)) + + ) + +273  + #__tou_l +( +c +, +lo +) \ + +274 + `__tobody + ( +c +, +__tou_l +, ( +lo +)-> +__y_tou +, (c,o)) + + ) + +275  + #tow_l +( +c +, +lo + + `__tow_l + ((c), (lo)) + + ) + +276  + #tou_l +( +c +, +lo + + `__tou_l + ((c), (lo)) + + ) + +280 #ide +__NO_CTYPE + + +281  + #__ium_l +( +c +, +l + + `__isy_l +((c), +_ISnum +, (l)) + + ) + +282  + #__iha_l +( +c +, +l + + `__isy_l +((c), +_ISpha +, (l)) + + ) + +283  + #__isl_l +( +c +, +l + + `__isy_l +((c), +_ISl +, (l)) + + ) + +284  + #__isdig_l +( +c +, +l + + `__isy_l +((c), +_ISdig +, (l)) + + ) + +285  + #__iow_l +( +c +, +l + + `__isy_l +((c), +_ISlow +, (l)) + + ) + +286  + #__isgph_l +( +c +, +l + + `__isy_l +((c), +_ISgph +, (l)) + + ) + +287  + #__irt_l +( +c +, +l + + `__isy_l +((c), +_ISt +, (l)) + + ) + +288  + #__iun_l +( +c +, +l + + `__isy_l +((c), +_ISpun +, (l)) + + ) + +289  + #__isa_l +( +c +, +l + + `__isy_l +((c), +_ISa +, (l)) + + ) + +290  + #__isu_l +( +c +, +l + + `__isy_l +((c), +_ISu +, (l)) + + ) + +291  + #__isxdig_l +( +c +, +l + + `__isy_l +((c), +_ISxdig +, (l)) + + ) + +293  + #__isbnk_l +( +c +, +l + + `__isy_l +((c), +_ISbnk +, (l)) + + ) + +295 #i +defed + +__USE_SVID + || defed +__USE_MISC + + +296  + #__iscii_l +( +c +, +l +(), + `__iscii + (c)) + + ) + +297  + #__tscii_l +( +c +, +l +(), + `__tscii + (c)) + + ) + +300  + #ium_l +( +c +, +l + + `__ium_l + ((c), (l)) + + ) + +301  + #iha_l +( +c +, +l + + `__iha_l + ((c), (l)) + + ) + +302  + #isl_l +( +c +, +l + + `__isl_l + ((c), (l)) + + ) + +303  + #isdig_l +( +c +, +l + + `__isdig_l + ((c), (l)) + + ) + +304  + #iow_l +( +c +, +l + + `__iow_l + ((c), (l)) + + ) + +305  + #isgph_l +( +c +, +l + + `__isgph_l + ((c), (l)) + + ) + +306  + #irt_l +( +c +, +l + + `__irt_l + ((c), (l)) + + ) + +307  + #iun_l +( +c +, +l + + `__iun_l + ((c), (l)) + + ) + +308  + #isa_l +( +c +, +l + + `__isa_l + ((c), (l)) + + ) + +309  + #isu_l +( +c +, +l + + `__isu_l + ((c), (l)) + + ) + +310  + #isxdig_l +( +c +, +l + + `__isxdig_l + ((c), (l)) + + ) + +312  + #isbnk_l +( +c +, +l + + `__isbnk_l + ((c), (l)) + + ) + +314 #i +defed + +__USE_SVID + || defed +__USE_MISC + + +315  + #iscii_l +( +c +, +l + + `__iscii_l + ((c), (l)) + + ) + +316  + #tscii_l +( +c +, +l + + `__tscii_l + ((c), (l)) + + ) + +323 +__END_DECLS + + + @/usr/include/gnu/stubs.h + +4  + ~ + +6 #i +__WORDSIZE + == 32 + +7  + ~ + +8 #i +__WORDSIZE + == 64 + +9  + ~ + + @/usr/include/sys/cdefs.h + +20 #idef +_SYS_CDEFS_H + + +21  + #_SYS_CDEFS_H + 1 + + ) + +24 #ide +_FEATURES_H + + +25  + ~ + +31 #i +defed + +__GNUC__ + && !defed +__STDC__ + + +36 #unde +__P + + +37 #unde +__PMT + + +39 #ifde +__GNUC__ + + +46 #i! +defed + +__lulus + && +__GNUC_PREREQ + (3, 3) + +47  + #__THROW + + `__ibu__ + (( +__nhrow__ +)) + + ) + +48  + #__NTH +( +f + + `__ibu__ + (( +__nhrow__ +) + ) +fct + +50 #i +defed + +__lulus + && +__GNUC_PREREQ + (2,8) + +51  + #__THROW + + `throw + () + + ) + +52  + #__NTH +( +f +f + `throw + () + + ) + +54  + #__THROW + + + ) + +55  + #__NTH +( +f + + ) +fct + +61  + #__le + + + ) + +63  + #__THROW + + + ) + +64  + #__NTH +( +f + + ) +fct + +66  + #__cڡ + cڡ + + ) + +67  + #__sigd + sigd + + ) + +68  + #__vީe + vީe + + ) + +74  + #__P +( +gs + + ) +args + +75  + #__PMT +( +gs + + ) +args + +80  + #__CONCAT +( +x +, +y +x ## + ) +y + +81  + #__STRING +( +x +#x + + ) + +84  + #__r_t + * + + ) + +85  + #__lg_doub_t +  + + ) + +89 #ifdef +__lulus + + +90  + #__BEGIN_DECLS + "C" { + + ) + +91  + #__END_DECLS + } + + ) + +93  + #__BEGIN_DECLS + + + ) + +94  + #__END_DECLS + + + ) + +103 #i +defed + +__lulus + && defed +_GLIBCPP_USE_NAMESPACES + + +104  + #__BEGIN_NAMESPACE_STD + +mea + +d + { + + ) + +105  + #__END_NAMESPACE_STD + } + + ) + +106  + #__USING_NAMESPACE_STD +( +me + +usg + +d +::me; + + ) + +107  + #__BEGIN_NAMESPACE_C99 + +mea + +__c99 + { + + ) + +108  + #__END_NAMESPACE_C99 + } + + ) + +109  + #__USING_NAMESPACE_C99 +( +me + +usg + +__c99 +::me; + + ) + +114  + #__BEGIN_NAMESPACE_STD + + + ) + +115  + #__END_NAMESPACE_STD + + + ) + +116  + #__USING_NAMESPACE_STD +( +me +) + + ) + +117  + #__BEGIN_NAMESPACE_C99 + + + ) + +118  + #__END_NAMESPACE_C99 + + + ) + +119  + #__USING_NAMESPACE_C99 +( +me +) + + ) + +124 #ide +__BOUNDED_POINTERS__ + + +125  + #__bounded + + + ) + +126  + #__unbounded + + + ) + +127  + #__rvue + + + ) + +132  + #__bos +( +r + + `__but_obje_size + (r, +__USE_FORTIFY_LEVEL + > 1) + + ) + +133  + #__bos0 +( +r + + `__but_obje_size + (r, 0) + + ) + +135 #i +__GNUC_PREREQ + (4,3) + +136  + #__wnde +( +me +, +msg +) \ + +137  + `me + ( + `__ibu__ +(( + `__wng__ + ( +msg +))) + + ) + +138  + #__wljr +( +msg + + `__ibu__ +(( + `__wng__ + (msg))) + + ) + +139  + #__rde +( +me +, +msg +) \ + +140  + `me + ( + `__ibu__ +(( + `__r__ + ( +msg +))) + + ) + +142  + #__wnde +( +me +, +msg +  + `me + () + + ) + +143  + #__wljr +( +msg +) + + ) + +144  + #__rde +( +me +, +msg +  + `me + () + + ) + +148 #i +__GNUC_PREREQ + (2,97) + +150  + #__exr + [] + + ) + +152 #ifde +__GNUC__ + + +153  + #__exr + [0] + + ) + +155 #i +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +156  + #__exr + [] + + ) + +159  + #__exr + [1] + + ) + +175 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +177  + #__REDIRECT +( +me +, +o +, +s +m + `__asm__ + ( + `__ASMNAME + (#s)) + + ) + +178 #ifde +__lulus + + +179  + #__REDIRECT_NTH +( +me +, +o +, +s +) \ + +180 +me + +o + +__THROW + + `__asm__ + ( + `__ASMNAME + (#s)) + + ) + +182  + #__REDIRECT_NTH +( +me +, +o +, +s +) \ + +183 +me + +o + + `__asm__ + ( + `__ASMNAME + (#s) +__THROW + + + ) + +185  + #__ASMNAME +( +ame + + `__ASMNAME2 + ( +__USER_LABEL_PREFIX__ +, cme) + + ) + +186  + #__ASMNAME2 +( +efix +, +ame + + `__STRING + (efix + ) +cname + +199 #i! +defed + +__GNUC__ + || __GNUC__ < 2 + +200  + #__ibu__ +( +xyz + + + ) + +206 #i +__GNUC_PREREQ + (2,96) + +207  + #__ibu_mloc__ + + `__ibu__ + (( +__mloc__ +)) + + ) + +209  + #__ibu_mloc__ + + + ) + +215 #i +__GNUC_PREREQ + (2,96) + +216  + #__ibu_pu__ + + `__ibu__ + (( +__pu__ +)) + + ) + +218  + #__ibu_pu__ + + + ) + +224 #i +__GNUC_PREREQ + (3,1) + +225  + #__ibu_ud__ + + `__ibu__ + (( +__ud__ +)) + + ) + +226  + #__ibu_nole__ + + `__ibu__ + (( +__nole__ +)) + + ) + +228  + #__ibu_ud__ + + `__ibu__ + (( +__unud__ +)) + + ) + +229  + #__ibu_nole__ + + + ) + +233 #i +__GNUC_PREREQ + (3,2) + +234  + #__ibu_dd__ + + `__ibu__ + (( +__dd__ +)) + + ) + +236  + #__ibu_dd__ + + + ) + +245 #i +__GNUC_PREREQ + (2,8) + +246  + #__ibu_fm_g__ +( +x + + `__ibu__ + (( + `__fm_g__ + (x))) + + ) + +248  + #__ibu_fm_g__ +( +x + + + ) + +255 #i +__GNUC_PREREQ + (2,97) + +256  + #__ibu_fm_rfm__ +( +a +, +b +) \ + +257 + `__ibu__ + (( + `__fm__ + ( +__rfm__ +, +a +, +b +))) + + ) + +259  + #__ibu_fm_rfm__ +( +a +, +b + + + ) + +264 #i +__GNUC_PREREQ + (3,3) + +265  + #__nnu +( +ms + + `__ibu__ + (( +__nnu__ +ams)) + + ) + +267  + #__nnu +( +ms +) + + ) + +272 #i +__GNUC_PREREQ + (3,4) + +273  + #__ibu_wn_unud_su__ + \ + +274 + `__ibu__ + (( +__wn_unud_su__ +)) + + ) + +275 #i +__USE_FORTIFY_LEVEL + > 0 + +276  + #__wur + +__ibu_wn_unud_su__ + + + ) + +279  + #__ibu_wn_unud_su__ + + + ) + +281 #ide +__wur + + +282  + #__wur + + + ) + +286 #i +__GNUC_PREREQ + (3,2) + +287  + #__ways_le + +__le + + `__ibu__ + (( +__ways_le__ +)) + + ) + +289  + #__ways_le + +__le + + + ) + +294 #i! +defed + +__lulus + || +__GNUC_PREREQ + (4,3) + +295 #i +defed + +__GNUC_STDC_INLINE__ + || defed +__lulus + + +296  + #__ex_le + +__le + + `__ibu__ + (( +__gnu_le__ +)) + + ) + +297 #i +__GNUC_PREREQ + (4,3) + +298  + #__ex_ways_le + \ + +299 +__ways_le + + `__ibu__ + (( +__gnu_le__ +, +__tificl__ +)) + + ) + +301  + #__ex_ways_le + \ + +302 +__ways_le + + `__ibu__ + (( +__gnu_le__ +)) + + ) + +305  + #__ex_le + +__le + + + ) + +306 #i +__GNUC_PREREQ + (4,3) + +307  + #__ex_ways_le + \ + +308 +__ways_le + + `__ibu__ + (( +__tificl__ +)) + + ) + +310  + #__ex_ways_le + +__ways_le + + + ) + +317 #i +__GNUC_PREREQ + (4,3) + +318  + #__va_g_ck +( + `__but_va_g_ck + () + + ) + +319  + #__va_g_ck_n +( + `__but_va_g_ck_n + () + + ) + +326 #i! +__GNUC_PREREQ + (2,8) + +327  + #__exnsi__ + + + ) + +331 #i! +__GNUC_PREREQ + (2,92) + +332  + #__ri + + + ) + +338 #i +__GNUC_PREREQ + (3,1&& ! +defed + +__GNUG__ + + +339  + #__ri_r + +__ri + + + ) + +341 #ifde +__GNUC__ + + +342  + #__ri_r + + + ) + +344 #i +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +345  + #__ri_r + +ri + + + ) + +348  + #__ri_r + + + ) + +353  + ~ + +355 #i +defed + +__LONG_DOUBLE_MATH_OPTIONAL + && defed +__NO_LONG_DOUBLE_MATH + + +356  + #__LDBL_COMPAT + 1 + + ) + +357 #ifde +__REDIRECT + + +358  + #__LDBL_REDIR1 +( +me +, +o +, +s + + `__REDIRECT + (me,ro,ls) + + ) + +359  + #__LDBL_REDIR +( +me +, +o +) \ + +360 + `__LDBL_REDIR1 + ( +me +, +o +, +__dbl_ +##me) + + ) + +361  + #__LDBL_REDIR1_NTH +( +me +, +o +, +s + + `__REDIRECT_NTH + (me,ro,ls) + + ) + +362  + #__LDBL_REDIR_NTH +( +me +, +o +) \ + +363 + `__LDBL_REDIR1_NTH + ( +me +, +o +, +__dbl_ +##me) + + ) + +364  + #__LDBL_REDIR1_DECL +( +me +, +s +) \ + +365 + `__tyof + ( +me +m + `__asm + ( + `__ASMNAME + (#s)); + + ) + +366  + #__LDBL_REDIR_DECL +( +me +) \ + +367 + `__tyof + ( +me +m + `__asm + ( + `__ASMNAME + ("__dbl_" #me)); + + ) + +368  + #__REDIRECT_LDBL +( +me +, +o +, +s +) \ + +369 + `__LDBL_REDIR1 + ( +me +, +o +, +__dbl_ +## +s +) + + ) + +370  + #__REDIRECT_NTH_LDBL +( +me +, +o +, +s +) \ + +371 + `__LDBL_REDIR1_NTH + ( +me +, +o +, +__dbl_ +## +s +) + + ) + +374 #i! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT + + +375  + #__LDBL_REDIR1 +( +me +, +o +, +s +m + ) +proto + +376  + #__LDBL_REDIR +( +me +, +o +m + ) +proto + +377  + #__LDBL_REDIR1_NTH +( +me +, +o +, +s +m +__THROW + + + ) + +378  + #__LDBL_REDIR_NTH +( +me +, +o +m +__THROW + + + ) + +379  + #__LDBL_REDIR_DECL +( +me +) + + ) + +380 #ifde +__REDIRECT + + +381  + #__REDIRECT_LDBL +( +me +, +o +, +s + + `__REDIRECT + (me,ro,ls) + + ) + +382  + #__REDIRECT_NTH_LDBL +( +me +, +o +, +s +) \ + +383 + `__REDIRECT_NTH + ( +me +, +o +, +s +) + + ) + + @/usr/include/bits/libc-lock.h + +20 #ide +_BITS_LIBC_LOCK_H + + +21  + #_BITS_LIBC_LOCK_H + 1 + + ) + +23  + ~ + +24  + #__ed_NULL + + + ) + +25  + ~ + +34 #ifde +_LIBC + + +35  + ~ + +36  + ~ + +37  + ~ + +38  + ~ + +39  + ~ + +43 #i +defed + +_LIBC + || defed +_IO_MTSAFE_IO + + +44 #i( +defed + +NOT_IN_libc + && !defed +IS_IN_libhad +|| !defed +_LIBC + + +45  +had_mux_t + + t__libc_lock_t +; + +46 ru { +had_mux_t + + mmux +; } + t__libc_lock_cursive_t +; + +48  + t__libc_lock_t +; + +49 ru {  + mlock +;  + mt +; * + mowr +; } + t__libc_lock_cursive_t +; + +51 ru { +had_mux_t + + mmux +; } + t__ld_lock_cursive_t +; + +52 #ifde +__USE_UNIX98 + + +53  +had_rwlock_t + + t__libc_rwlock_t +; + +55  +__libc_rwlock_aque__ + + t__libc_rwlock_t +; + +58  +__libc_lock_aque__ + + t__libc_lock_t +; + +59  +__libc_lock_cursive_aque__ + + t__libc_lock_cursive_t +; + +60  +__libc_rwlock_aque__ + + t__libc_rwlock_t +; + +64  +had_key_t + + t__libc_key_t +; + +73  + #__libc_lock_defe +( +CLASS +, +NAME +) \ + +74 +CLASS + +__libc_lock_t + +NAME +; + + ) + +75  + #__libc_rwlock_defe +( +CLASS +, +NAME +) \ + +76 +CLASS + +__libc_rwlock_t + +NAME +; + + ) + +77  + #__libc_lock_defe_cursive +( +CLASS +, +NAME +) \ + +78 +CLASS + +__libc_lock_cursive_t + +NAME +; + + ) + +79  + #__ld_lock_defe_cursive +( +CLASS +, +NAME +) \ + +80 +CLASS + +__ld_lock_cursive_t + +NAME +; + + ) + +91 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +92 #i +LLL_LOCK_INITIALIZER + == 0 + +93  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +94 +CLASS + +__libc_lock_t + +NAME +; + + ) + +96  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +97 +CLASS + +__libc_lock_t + +NAME + = +LLL_LOCK_INITIALIZER +; + + ) + +100 #i +__LT_SPINLOCK_INIT + == 0 + +101  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +102 +CLASS + +__libc_lock_t + +NAME +; + + ) + +104  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +105 +CLASS + +__libc_lock_t + +NAME + = +PTHREAD_MUTEX_INITIALIZER +; + + ) + +109  + #__libc_rwlock_defe_lized +( +CLASS +, +NAME +) \ + +110 +CLASS + +__libc_rwlock_t + +NAME + = +PTHREAD_RWLOCK_INITIALIZER +; + + ) + +114 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +115 #i +LLL_LOCK_INITIALIZER + == 0 + +116  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +117 +CLASS + +__libc_lock_cursive_t + +NAME +; + + ) + +119  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +120 +CLASS + +__libc_lock_cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +122  + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +123 { +LLL_LOCK_INITIALIZER +, 0, +NULL + } + + ) + +125  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +126 +CLASS + +__libc_lock_cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +127  + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +128 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +131  + #__ld_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +132 +CLASS + +__ld_lock_cursive_t + +NAME + = +_RTLD_LOCK_RECURSIVE_INITIALIZER +; + + ) + +133  + #_RTLD_LOCK_RECURSIVE_INITIALIZER + \ + +134 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +136  + #__ld_lock_lize +( +NAME +) \ + +137 ((( +NAME +( +__ld_lock_cursive_t + +_RTLD_LOCK_RECURSIVE_INITIALIZER +) + + ) + +144 #ifde +__PIC__ + + +145  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +) \ + +146 ( + `__exnsi__ + ({ + `__tyof + ( +FUNC +* +_ + = (FUNC); \ + +147 +_ + ! +NULL + ? (*_ +ARGS + : +ELSE +; })) + + ) + +149  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +) \ + +150 ( +FUNC + ! +NULL + ? FUNC +ARGS + : +ELSE +) + + ) + +154 #i +defed + +SHARED + && !defed +NOT_IN_libc + + +155  + #PTFAVAIL +( +NAME + +__libc_had_funis_ + + + ) + +156  + #__libc_f_ +( +FUNC +, +ARGS +, +ELSE +) \ + +157 ( +__libc_had_funis_ + ? + `PTHFCT_CALL + ( +r_ +## +FUNC +, +ARGS +: +ELSE +) + + ) + +158  + #__libc_f__ways +( +FUNC +, +ARGS +) \ + +159 + `PTHFCT_CALL + ( +r_ +## +FUNC +, +ARGS +) + + ) + +161  + #PTFAVAIL +( +NAME +(NAME ! +NULL +) + + ) + +162  + #__libc_f_ +( +FUNC +, +ARGS +, +ELSE +) \ + +163 + `__libc_maybe_ + ( +FUNC +, +ARGS +, +ELSE +) + + ) + +164  + #__libc_f__ways +( +FUNC +, +ARGS +) \ + +165 +FUNC + +ARGS + + + ) + +171 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +172  + #__libc_lock_ +( +NAME +((NAME +LLL_LOCK_INITIALIZER +, 0) + + ) + +174  + #__libc_lock_ +( +NAME +) \ + +175 + `__libc_maybe_ + ( +__had_mux_ +, (&( +NAME +), +NULL +), 0) + + ) + +177 #i +defed + +SHARED + && !defed +NOT_IN_libc + + +180  + #__libc_rwlock_ +( +NAME +) \ + +181 ( + `__but_memt + (&( +NAME +), '\0',  (NAME)), 0) + + ) + +183  + #__libc_rwlock_ +( +NAME +) \ + +184 + `__libc_maybe_ + ( +__had_rwlock_ +, (&( +NAME +), +NULL +), 0) + + ) + +188 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +189  + #__libc_lock__cursive +( +NAME +) \ + +190 (( +NAME +( +__libc_lock_cursive_t + +_LIBC_LOCK_RECURSIVE_INITIALIZER +, 0) + + ) + +192  + #__libc_lock__cursive +( +NAME +) \ + +194 i( +__had_mux_ + ! +NULL +) \ + +196 +had_mux_t + +__ +; \ + +197 + `__had_mux_ + (& +__ +); \ + +198 + `__had_mux_y + (& +__ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +199 + `__had_mux_ + (&( +NAME +). +mux +, & +__ +); \ + +200 + `__had_mux_deroy + (& +__ +); \ + +202 } 0) + + ) + +205  + #__ld_lock__cursive +( +NAME +) \ + +207 i( +__had_mux_ + ! +NULL +) \ + +209 +had_mux_t + +__ +; \ + +210 + `__had_mux_ + (& +__ +); \ + +211 + `__had_mux_y + (& +__ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +212 + `__had_mux_ + (&( +NAME +). +mux +, & +__ +); \ + +213 + `__had_mux_deroy + (& +__ +); \ + +215 } 0) + + ) + +220 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +221  + #__libc_lock_fi +( +NAME +((0) + + ) + +223  + #__libc_lock_fi +( +NAME +) \ + +224 + `__libc_maybe_ + ( +__had_mux_deroy +, (&( +NAME +)), 0) + + ) + +226 #i +defed + +SHARED + && !defed +NOT_IN_libc + + +227  + #__libc_rwlock_fi +( +NAME +((0) + + ) + +229  + #__libc_rwlock_fi +( +NAME +) \ + +230 + `__libc_maybe_ + ( +__had_rwlock_deroy +, (&( +NAME +)), 0) + + ) + +234 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +235  + #__libc_lock_fi_cursive +( +NAME +((0) + + ) + +237  + #__libc_lock_fi_cursive +( +NAME +) \ + +238 + `__libc_maybe_ + ( +__had_mux_deroy +, (&( +NAME +)), 0) + + ) + +242 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +243 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +247  +__libc_lock_lock_ + ( +__libc_lock_t + *); + +248 +libc_hidd_o + ( +__libc_lock_lock_ +); + +250 #i +__OPTION_EGLIBC_BIG_MACROS + + +251  + #__libc_lock_lock +( +NAME +) \ + +252 ({ + `l_lock + ( +NAME +, +LLL_PRIVATE +); 0; }) + + ) + +254  + #__libc_lock_lock +( +NAME +) \ + +255 + `__libc_lock_lock_ + (&( +NAME +)) + + ) + +258  + #__libc_lock_lock +( +NAME +) \ + +259 + `__libc_maybe_ + ( +__had_mux_lock +, (&( +NAME +)), 0) + + ) + +261  + #__libc_rwlock_rdlock +( +NAME +) \ + +262 + `__libc_f_ + ( +__had_rwlock_rdlock +, (&( +NAME +)), 0) + + ) + +263  + #__libc_rwlock_wock +( +NAME +) \ + +264 + `__libc_f_ + ( +__had_rwlock_wock +, (&( +NAME +)), 0) + + ) + +267 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +268 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +272  +__libc_lock_lock_cursive_ + ( +__libc_lock_cursive_t + *); + +273 +libc_hidd_o + ( +__libc_lock_lock_cursive_ +); + +275 #i +__OPTION_EGLIBC_BIG_MACROS + + +276  + #__libc_lock_lock_cursive +( +NAME +) \ + +278 * +lf + = +THREAD_SELF +; \ + +279 i(( +NAME +). +owr + ! +lf +) \ + +281 + `l_lock + (( +NAME +). +lock +, +LLL_PRIVATE +); \ + +282 ( +NAME +). +owr + = +lf +; \ + +284 ++( +NAME +). +t +; \ + +285 } 0) + + ) + +287  + #__libc_lock_lock_cursive +( +NAME +) \ + +288 + `__libc_lock_lock_cursive_ + (&( +NAME +)) + + ) + +291  + #__libc_lock_lock_cursive +( +NAME +) \ + +292 + `__libc_maybe_ + ( +__had_mux_lock +, (&( +NAME +). +mux +), 0) + + ) + +296 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +297 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +301  +__libc_lock_ylock_ + ( +__libc_lock_t + *); + +302 +libc_hidd_o + ( +__libc_lock_ylock_ +); + +304 #i +__OPTION_EGLIBC_BIG_MACROS + + +305  + #__libc_lock_ylock +( +NAME +) \ + +306 + `l_ylock + ( +NAME +) + + ) + +308  + #__libc_lock_ylock +( +NAME +) \ + +309 + `__libc_lock_ylock_ + (&( +NAME +)) + + ) + +312  + #__libc_lock_ylock +( +NAME +) \ + +313 + `__libc_maybe_ + ( +__had_mux_ylock +, (&( +NAME +)), 0) + + ) + +315  + #__libc_rwlock_yrdlock +( +NAME +) \ + +316 + `__libc_maybe_ + ( +__had_rwlock_yrdlock +, (&( +NAME +)), 0) + + ) + +317  + #__libc_rwlock_ywock +( +NAME +) \ + +318 + `__libc_maybe_ + ( +__had_rwlock_ywock +, (&( +NAME +)), 0) + + ) + +321 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +322 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +326  +__libc_lock_ylock_cursive_ + ( +__libc_lock_cursive_t + *); + +327 +libc_hidd_o + ( +__libc_lock_ylock_cursive_ +); + +329 #i +__OPTION_EGLIBC_BIG_MACROS + + +330  + #__libc_lock_ylock_cursive +( +NAME +) \ + +332  +su + = 0; \ + +333 * +lf + = +THREAD_SELF +; \ + +334 i(( +NAME +). +owr + ! +lf +) \ + +336 i( + `l_ylock + (( +NAME +). +lock +) == 0) \ + +338 ( +NAME +). +owr + = +lf +; \ + +339 ( +NAME +). +t + = 1; \ + +342 +su + = +EBUSY +; \ + +345 ++( +NAME +). +t +; \ + +346 +su +; \ + +347 }) + + ) + +349  + #__libc_lock_ylock_cursive +( +NAME +) \ + +350 + `__libc_lock_ylock_cursive_ + (&( +NAME +)) + + ) + +353  + #__libc_lock_ylock_cursive +( +NAME +) \ + +354 + `__libc_maybe_ + ( +__had_mux_ylock +, (&( +NAME +)), 0) + + ) + +357  + #__ld_lock_ylock_cursive +( +NAME +) \ + +358 + `__libc_maybe_ + ( +__had_mux_ylock +, (&( +NAME +). +mux +), 0) + + ) + +361 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +362 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +366  +__libc_lock_uock_ + ( +__libc_lock_t + *); + +367 +libc_hidd_o + ( +__libc_lock_uock_ +); + +369 #i +__OPTION_EGLIBC_BIG_MACROS + + +370  + #__libc_lock_uock +( +NAME +) \ + +371 + `l_uock + ( +NAME +, +LLL_PRIVATE +) + + ) + +373  + #__libc_lock_uock +( +NAME +) \ + +374 + `__libc_lock_uock_ + (&( +NAME +)) + + ) + +377  + #__libc_lock_uock +( +NAME +) \ + +378 + `__libc_maybe_ + ( +__had_mux_uock +, (&( +NAME +)), 0) + + ) + +380  + #__libc_rwlock_uock +( +NAME +) \ + +381 + `__libc_f_ + ( +__had_rwlock_uock +, (&( +NAME +)), 0) + + ) + +384 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +385 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +389  +__libc_lock_uock_cursive_ + ( +__libc_lock_cursive_t + *); + +390 +libc_hidd_o + ( +__libc_lock_uock_cursive_ +); + +392 #i +__OPTION_EGLIBC_BIG_MACROS + + +394  + #__libc_lock_uock_cursive +( +NAME +) \ + +396 i(--( +NAME +). +t + == 0) \ + +398 ( +NAME +). +owr + = +NULL +; \ + +399 + `l_uock + (( +NAME +). +lock +, +LLL_PRIVATE +); \ + +401 } 0) + + ) + +403  + #__libc_lock_uock_cursive +( +NAME +) \ + +404 + `__libc_lock_uock_cursive_ + (&( +NAME +)) + + ) + +407  + #__libc_lock_uock_cursive +( +NAME +) \ + +408 + `__libc_maybe_ + ( +__had_mux_uock +, (&( +NAME +)), 0) + + ) + +411 #i +defed + +_LIBC + && defed +SHARED + + +412  + #__ld_lock_deu_lock_cursive +( +lock +) \ + +413 ++(( +had_mux_t + *)( +lock +))-> +__da +. +__cou +; + + ) + +415  + #__ld_lock_deu_uock_cursive +( +lock +) \ + +416 --(( +had_mux_t + *)( +lock +))-> +__da +. +__cou +; + + ) + +418  + #__ld_lock_lock_cursive +( +NAME +) \ + +419 + `GL +( +dl_ld_lock_cursive +(&( +NAME +). +mux +) + + ) + +421  + #__ld_lock_uock_cursive +( +NAME +) \ + +422 + `GL +( +dl_ld_uock_cursive +(&( +NAME +). +mux +) + + ) + +424  + #__ld_lock_lock_cursive +( +NAME +) \ + +425 + `__libc_maybe_ + ( +__had_mux_lock +, (&( +NAME +). +mux +), 0) + + ) + +427  + #__ld_lock_uock_cursive +( +NAME +) \ + +428 + `__libc_maybe_ + ( +__had_mux_uock +, (&( +NAME +). +mux +), 0) + + ) + +432 #i +PTHREAD_ONCE_INIT + == 0 + +435  + #__libc__defe +( +CLASS +, +NAME +) \ + +436 +CLASS + +had__t + +NAME + + + ) + +438  + #__libc__defe +( +CLASS +, +NAME +) \ + +439 +CLASS + +had__t + +NAME + = +PTHREAD_ONCE_INIT + + + ) + +443  + #__libc_ +( +ONCE_CONTROL +, +INIT_FUNCTION +) \ + +445 i( + `PTFAVAIL + ( +__had_ +)) \ + +446 + `__libc_f__ways + ( +__had_ +, (&( +ONCE_CONTROL +), \ + +447 +INIT_FUNCTION +)); \ + +448 i(( +ONCE_CONTROL += +PTHREAD_ONCE_INIT +) { \ + +449 + `INIT_FUNCTION + (); \ + +450 ( +ONCE_CONTROL +) |= 2; \ + +452 } 0) + + ) + +459  +_had_nup_push + ( +_had_nup_bufr + * +bufr +, + +460 (* +route +(*), * +g +); + +461  + `_had_nup_p + ( +_had_nup_bufr + * +bufr +, + +462  +execu +); + +463  + `_had_nup_push_der + ( +_had_nup_bufr + * +bufr +, + +464 (* +route +(*), * +g +); + +465  + `_had_nup_p_e + ( +_had_nup_bufr + * +bufr +, + +466  +execu +); + +469  + #__libc_nup_gi_t +( +DOIT +, +FCT +, +ARG +) \ + +470 {  +_had_nup_bufr + +_bufr +; \ + +471  +_ava +; \ + +472 i( +DOIT +) { \ + +473 +_ava + = + `PTFAVAIL + ( +_had_nup_push_der +); \ + +474 i( +_ava +) { \ + +475 + `__libc_f__ways + ( +_had_nup_push_der +, (& +_bufr +, +FCT +, \ + +476 +ARG +)); \ + +478 +_bufr +. +__route + = ( +FCT +); \ + +479 +_bufr +. +__g + = ( +ARG +); \ + +482 +_ava + = 0; \ + +483 } + + ) + +486  + #__libc_nup_gi_d +( +DOIT +) \ + +487 i( +_ava +) { \ + +488 + `__libc_f__ways + ( +_had_nup_p_e +, (& +_bufr +, +DOIT +));\ + +489 } i( +DOIT +) \ + +490 +_bufr +. + `__route + (_bufr. +__g +); \ + +491 + } + + ) +} + +494  + #__libc_nup_d +( +DOIT +) \ + +495 i( +_ava +) { \ + +496 + `__libc_f__ways + ( +_had_nup_p_e +, (& +_bufr +, +DOIT +));\ + +497 } i( +DOIT +) \ + +498 +_bufr +. + `__route + (_bufr. +__g +) + + ) + +502 +__ex_le +  + +503 + $__libc_nup_route + ( +__had_nup_ame + * +f +) + +505 i( +f +-> +__do_ +) + +506 +f +-> + `__nl_route + (f-> +__nl_g +); + +507 + } +} + +509  + #__libc_nup_push +( +f +, +g +) \ + +511  +__had_nup_ame + +__ame + \ + +512 + `__ibu__ + (( + `__nup__ + ( +__libc_nup_route +))) \ + +513 { . +__nl_route + = ( +f +), . +__nl_g + = ( +g +), \ + +514 . +__do_ + = 1 }; + + ) + +516  + #__libc_nup_p +( +execu +) \ + +517 +__ame +. +__do_ + = ( +execu +); \ + +518 } 0) + + ) + +522  + #__libc_key_ +( +KEY +, +DESTRUCTOR +) \ + +523 + `__libc_f_ + ( +__had_key_ +, ( +KEY +, +DESTRUCTOR +), 1) + + ) + +526  + #__libc_gecific +( +KEY +) \ + +527 + `__libc_f_ + ( +__had_gecific +, ( +KEY +), +NULL +) + + ) + +530  + #__libc_tecific +( +KEY +, +VALUE +) \ + +531 + `__libc_f_ + ( +__had_tecific +, ( +KEY +, +VALUE +), 0) + + ) + +537  + #__libc_fk +( +PREPARE +, +PARENT +, +CHILD +) \ + +538 + `__gi_fk + ( +PREPARE +, +PARENT +, +CHILD +, +NULL +) + + ) + +539  +__gi_fk + ((* +__e +) (), + +540 (* +__ +) (), + +541 (* +__chd +) (), + +542 * +__dso_hd +); + +547  + `__had_mux_ + ( +had_mux_t + * +__mux +, + +548 +__cڡ + +had_mux_t + * +__mux_ +); + +550  + `__had_mux_deroy + ( +had_mux_t + * +__mux +); + +552  + `__had_mux_ylock + ( +had_mux_t + * +__mux +); + +554  + `__had_mux_lock + ( +had_mux_t + * +__mux +); + +556  + `__had_mux_uock + ( +had_mux_t + * +__mux +); + +558  + `__had_mux_ + ( +had_mux_t + * +__ +); + +560  + `__had_mux_deroy + ( +had_mux_t + * +__ +); + +562  + `__had_mux_y + ( +had_mux_t + * +__ +, + +563  +__kd +); + +565 #ifde +__USE_UNIX98 + + +566  + `__had_rwlock_ + ( +had_rwlock_t + * +__rwlock +, + +567 +__cڡ + +had_rwlock_t + * +__ +); + +569  + `__had_rwlock_deroy + ( +had_rwlock_t + * +__rwlock +); + +571  + `__had_rwlock_rdlock + ( +had_rwlock_t + * +__rwlock +); + +573  + `__had_rwlock_yrdlock + ( +had_rwlock_t + * +__rwlock +); + +575  + `__had_rwlock_wock + ( +had_rwlock_t + * +__rwlock +); + +577  + `__had_rwlock_ywock + ( +had_rwlock_t + * +__rwlock +); + +579  + `__had_rwlock_uock + ( +had_rwlock_t + * +__rwlock +); + +582  + `__had_key_ + ( +had_key_t + * +__key +, + +583 (* +__der_funi +) (*)); + +585  + `__had_tecific + ( +had_key_t + +__key +, + +586 +__cڡ + * +__por +); + +588 * + `__had_gecific + ( +had_key_t + +__key +); + +590  + `__had_ + ( +had__t + * +___cڌ +, + +591 (* +___route +) ()); + +593  + `__had_fk + ((* +__e +) (), + +594 (* +__ +) (), + +595 (* +__chd +) ()); + +601 #ide +__NO_WEAK_PTHREAD_ALIASES + + +602 #ifde +wk_ex + + +603 #i +_LIBC + + +604  + ~ + +606  + #BP_SYM +( +sym + + ) +sym + +608 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ +)) + +609 + `wk_ex + ( + $BP_SYM + ( +__had_mux_deroy +)) + +610 + `wk_ex + ( + $BP_SYM + ( +__had_mux_lock +)) + +611 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ylock +)) + +612 + `wk_ex + ( + $BP_SYM + ( +__had_mux_uock +)) + +613 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ +)) + +614 + `wk_ex + ( + $BP_SYM + ( +__had_mux_deroy +)) + +615 + `wk_ex + ( + $BP_SYM + ( +__had_mux_y +)) + +616 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_ +)) + +617 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_deroy +)) + +618 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_rdlock +)) + +619 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_yrdlock +)) + +620 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_wock +)) + +621 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_ywock +)) + +622 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_uock +)) + +623 + `wk_ex + ( + $BP_SYM + ( +__had_key_ +)) + +624 + `wk_ex + ( + $BP_SYM + ( +__had_tecific +)) + +625 + `wk_ex + ( + $BP_SYM + ( +__had_gecific +)) + +626 + `wk_ex + ( + $BP_SYM + ( +__had_ +)) + +627 + $wk_ex + ( +__had_lize +) + +628 + $wk_ex + ( +__had_fk +) + +629 + `wk_ex + ( + $BP_SYM + ( +_had_nup_push_der +)) + +630 + `wk_ex + ( + $BP_SYM + ( +_had_nup_p_e +)) + +631 + `wk_ex + ( + $BP_SYM + ( +had_tnle +)) + +633 #agm +wk + +__had_mux_ + + +634 #agm +wk + +__had_mux_deroy + + +635 #agm +wk + +__had_mux_lock + + +636 #agm +wk + +__had_mux_ylock + + +637 #agm +wk + +__had_mux_uock + + +638 #agm +wk + +__had_mux_ + + +639 #agm +wk + +__had_mux_deroy + + +640 #agm +wk + +__had_mux_y + + +641 #agm +wk + +__had_rwlock_deroy + + +642 #agm +wk + +__had_rwlock_rdlock + + +643 #agm +wk + +__had_rwlock_yrdlock + + +644 #agm +wk + +__had_rwlock_wock + + +645 #agm +wk + +__had_rwlock_ywock + + +646 #agm +wk + +__had_rwlock_uock + + +647 #agm +wk + +__had_key_ + + +648 #agm +wk + +__had_tecific + + +649 #agm +wk + +__had_gecific + + +650 #agm +wk + +__had_ + + +651 #agm +wk + +__had_lize + + +652 #agm +wk + +__had_fk + + +653 #agm +wk + +_had_nup_push_der + + +654 #agm +wk + +_had_nup_p_e + + +655 #agm +wk + +had_tnle + + + @/usr/include/endian.h + +19 #idef +_ENDIAN_H + + +20  + #_ENDIAN_H + 1 + + ) + +22  + ~ + +32  + #__LITTLE_ENDIAN + 1234 + + ) + +33  + #__BIG_ENDIAN + 4321 + + ) + +34  + #__PDP_ENDIAN + 3412 + + ) + +37  + ~ + +41 #ide +__FLOAT_WORD_ORDER + + +42  + #__FLOAT_WORD_ORDER + +__BYTE_ORDER + + + ) + +45 #ifdef +__USE_BSD + + +46  + #LITTLE_ENDIAN + +__LITTLE_ENDIAN + + + ) + +47  + #BIG_ENDIAN + +__BIG_ENDIAN + + + ) + +48  + #PDP_ENDIAN + +__PDP_ENDIAN + + + ) + +49  + #BYTE_ORDER + +__BYTE_ORDER + + + ) + +52 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +53  + #__LONG_LONG_PAIR +( +HI +, +LO +LO, + ) +HI + +54 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +55  + #__LONG_LONG_PAIR +( +HI +, +LO +HI, + ) +LO + +59 #ifde +__USE_BSD + + +61  + ~ + +63 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +64  + #htobe16 +( +x + + `__bsw_16 + (x) + + ) + +65  + #hte16 +( +x +(x) + + ) + +66  + #be16toh +( +x + + `__bsw_16 + (x) + + ) + +67  + #16toh +( +x +(x) + + ) + +69  + #htobe32 +( +x + + `__bsw_32 + (x) + + ) + +70  + #hte32 +( +x +(x) + + ) + +71  + #be32toh +( +x + + `__bsw_32 + (x) + + ) + +72  + #32toh +( +x +(x) + + ) + +74  + #htobe64 +( +x + + `__bsw_64 + (x) + + ) + +75  + #hte64 +( +x +(x) + + ) + +76  + #be64toh +( +x + + `__bsw_64 + (x) + + ) + +77  + #64toh +( +x +(x) + + ) + +79  + #htobe16 +( +x +(x) + + ) + +80  + #hte16 +( +x + + `__bsw_16 + (x) + + ) + +81  + #be16toh +( +x +(x) + + ) + +82  + #16toh +( +x + + `__bsw_16 + (x) + + ) + +84  + #htobe32 +( +x +(x) + + ) + +85  + #hte32 +( +x + + `__bsw_32 + (x) + + ) + +86  + #be32toh +( +x +(x) + + ) + +87  + #32toh +( +x + + `__bsw_32 + (x) + + ) + +89  + #htobe64 +( +x +(x) + + ) + +90  + #hte64 +( +x + + `__bsw_64 + (x) + + ) + +91  + #be64toh +( +x +(x) + + ) + +92  + #64toh +( +x + + `__bsw_64 + (x) + + ) + + @/usr/include/gconv.h + +23 #ide +_GCONV_H + + +24  + #_GCONV_H + 1 + + ) + +26  + ~ + +27  + #__ed_mbe_t + + + ) + +28  + #__ed_wt_t + + + ) + +29  + ~ + +30  + #__ed_size_t + + + ) + +31  + #__ed_wch_t + + + ) + +32  + ~ + +35  + #__UNKNOWN_10646_CHAR + (( +wch_t +0xfffd) + + ) + +40 + m__GCONV_OK + = 0, + +41 + m__GCONV_NOCONV +, + +42 + m__GCONV_NODB +, + +43 + m__GCONV_NOMEM +, + +45 + m__GCONV_EMPTY_INPUT +, + +46 + m__GCONV_FULL_OUTPUT +, + +47 + m__GCONV_ILLEGAL_INPUT +, + +48 + m__GCONV_INCOMPLETE_INPUT +, + +50 + m__GCONV_ILLEGAL_DESCRIPTOR +, + +51 + m__GCONV_INTERNAL_ERROR + + +58 + m__GCONV_IS_LAST + = 0x0001, + +59 + m__GCONV_IGNORE_ERRORS + = 0x0002 + +64  + g__gcv_ +; + +65  + g__gcv__da +; + +66  + g__gcv_lded_obje +; + +67  + g__gcv_s_da +; + +71 (* + t__gcv_f +( + t__gcv_ + *,  + t__gcv__da + *, + +72 + t__cڡ + **, __const *, + +73 **, + tsize_t + *, , ); + +76  + $wt_t + (* + t__gcv_btowc_f +( + t__gcv_ + *, ); + +79 (* + t__gcv__f +( + t__gcv_ + *); + +80 (* + t__gcv_d_f +( + t__gcv_ + *); + +84 (* + t__gcv_s_f +( + t__gcv_ + *, + +85  + t__gcv__da + *, *, + +86 + t__cڡ + *, + +87 + t__cڡ + **, + +88 + t__cڡ + *, **, + +89 + tsize_t + *); + +92 (* + t__gcv_s_cڋxt_f +(*, + t__cڡ + *, + +93 + t__cڡ + *, + +97 (* + t__gcv_s_quy_f +( + t__cڡ + *, __const ***, + +98 + tsize_t + *); + +101 (* + t__gcv_s__f +) (**, const *); + +102 (* + t__gcv_s_d_f +) (*); + +104  + s__gcv_s_da + + +107 +__gcv_s_f + +__s_f +; + +108 +__gcv_s_cڋxt_f + +__s_cڋxt_f +; + +109 +__gcv_s_d_f + +__s_d_f +; + +110 * +__da +; + +111  +__gcv_s_da + * +__xt +; + +116  + s__gcv_ + + +118  +__gcv_lded_obje + * +__shlib_hd +; + +119 +__cڡ + * +__modme +; + +121  +__cou +; + +123 * +__om_me +; + +124 * +__to_me +; + +126 +__gcv_f + +__f +; + +127 +__gcv_btowc_f + +__btowc_f +; + +128 +__gcv__f + +___f +; + +129 +__gcv_d_f + +__d_f +; + +133  +__m_eded_om +; + +134  +__max_eded_om +; + +135  +__m_eded_to +; + +136  +__max_eded_to +; + +139  +__eful +; + +141 * +__da +; + +146  + s__gcv__da + + +148 * +__outbuf +; + +149 * +__outbund +; + +153  +__ags +; + +157  +__voti_cou +; + +161  +___u +; + +163 +__mbe_t + * +__ +; + +164 +__mbe_t + +__e +; + +168  +__gcv_s_da + * +__s +; + +173  + s__gcv_fo + + +175 +size_t + +__ns +; + +176  +__gcv_ + * +__s +; + +177 +__exnsi__ +  +__gcv__da + +__da + +__exr +; + +178 } * + t__gcv_t +; + + @/usr/include/gnu/stubs-32.h + +6 #ifde +_LIBC + + +7 #r +Alitis + +may + +n + +defe + +the + +mao + +_LIBC + + +10  + #__ub___kl_co + + + ) + +11  + #__ub___kl_sl + + + ) + +12  + #__ub___kl_ + + + ) + +13  + #__ub_chags + + + ) + +14  + #__ub_ach + + + ) + +15  + #__ub_fchags + + + ) + +16  + #__ub_fdach + + + ) + +17  + #__ub_gy + + + ) + +18  + #__ub_lchmod + + + ) + +19  + #__ub_voke + + + ) + +20  + #__ub_og + + + ) + +21  + #__ub_sigtu + + + ) + +22  + #__ub_sk + + + ) + +23  + #__ub_ty + + + ) + + @/usr/include/gnu/stubs-64.h + +6 #ifde +_LIBC + + +7 #r +Alitis + +may + +n + +defe + +the + +mao + +_LIBC + + +10  + #__ub_bdush + + + ) + +11  + #__ub_chags + + + ) + +12  + #__ub_ach + + + ) + +13  + #__ub_fchags + + + ) + +14  + #__ub_fdach + + + ) + +15  + #__ub_gmsg + + + ) + +16  + #__ub_gy + + + ) + +17  + #__ub_lchmod + + + ) + +18  + #__ub_putmsg + + + ) + +19  + #__ub_voke + + + ) + +20  + #__ub_og + + + ) + +21  + #__ub_sigtu + + + ) + +22  + #__ub_sk + + + ) + +23  + #__ub_ty + + + ) + + @/usr/include/wchar.h + +24 #ide +_WCHAR_H + + +26 #i! +defed + +__ed_mbe_t + && !defed +__ed_wt_t + + +27  + #_WCHAR_H + 1 + + ) + +28  + ~ + +31 #ifde +_WCHAR_H + + +33  + #__ed___FILE + + + ) + +34 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +35  + #__ed_FILE + + + ) + +37  + ~ + +39  + #__ed___va_li + + + ) + +40  + ~ + +42  + ~ + +45  + #__ed_size_t + + + ) + +46  + #__ed_wch_t + + + ) + +47  + #__ed_NULL + + + ) + +49 #i +defed + +_WCHAR_H + || defed +__ed_wt_t + || !defed +__WINT_TYPE__ + + +50 #unde +__ed_wt_t + + +51  + #__ed_wt_t + + + ) + +52  + ~ + +55 #i +defed + +__lulus + && +__GNUC_PREREQ + (4, 4) + +56  + #__CORRECT_ISO_CPP_WCHAR_H_PROTO + + + ) + +61 #ide +_WINT_T + + +66  + #_WINT_T + + + ) + +67  + twt_t +; + +71 #i +defed + +__lulus + && defed +_GLIBCPP_USE_NAMESPACES + \ + +72 && +defed + +__WINT_TYPE__ + + +73 +__BEGIN_NAMESPACE_STD + + +74  +__WINT_TYPE__ + + twt_t +; + +75 + g__END_NAMESPACE_STD + + +80 #i( +defed + +_WCHAR_H + || defed +__ed_mbe_t +&& !defed +__mbe_t_defed + + +81  + #__mbe_t_defed + 1 + + ) + +85  + m__cou +; + +88 #ifde +__WINT_TYPE__ + + +89 +__WINT_TYPE__ + + m__wch +; + +91 +wt_t + + m__wch +; + +93  + m__wchb +[4]; + +94 } + m__vue +; + +95 } + t__mbe_t +; + +97 #unde +__ed_mbe_t + + +102 #ifde +_WCHAR_H + + +104 +__BEGIN_NAMESPACE_C99 + + +106  +__mbe_t + + tmbe_t +; + +107 + g__END_NAMESPACE_C99 + + +108 #ifde +__USE_GNU + + +109 + $__USING_NAMESPACE_C99 +( +mbe_t +) + +112 #ide +WCHAR_MIN + + +114  + #WCHAR_MIN + +__WCHAR_MIN + + + ) + +115  + #WCHAR_MAX + +__WCHAR_MAX + + + ) + +118 #ide +WEOF + + +119  + #WEOF + (0xffffffffu) + + ) + +124 #i +defed + +__USE_XOPEN + && !defed +__USE_UNIX98 + + +125  + ~ + +129 +__BEGIN_DECLS + + +131 +__BEGIN_NAMESPACE_STD + + +134  +tm +; + +135 +__END_NAMESPACE_STD + + +139 + $__USING_NAMESPACE_STD +( +tm +) + +142 +__BEGIN_NAMESPACE_STD + + +144 +wch_t + * + $wcsy + ( +wch_t + * +__ri + +__de +, + +145 +__cڡ + +wch_t + * +__ri + +__c + +__THROW +; + +147 +wch_t + * + $wcy + ( +wch_t + * +__ri + +__de +, + +148 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +) + +149 +__THROW +; + +152 +wch_t + * + $wcst + ( +wch_t + * +__ri + +__de +, + +153 +__cڡ + +wch_t + * +__ri + +__c + +__THROW +; + +155 +wch_t + * + $wct + ( +wch_t + * +__ri + +__de +, + +156 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +) + +157 +__THROW +; + +160  + $wcscmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +) + +161 +__THROW + +__ibu_pu__ +; + +163  + $wccmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, +size_t + +__n +) + +164 +__THROW + +__ibu_pu__ +; + +165 +__END_NAMESPACE_STD + + +167 #ifde +__USE_XOPEN2K8 + + +169  + $wcscmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 + +__THROW +; + +172  + $wccmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +173 +size_t + +__n + +__THROW +; + +177  + ~ + +179  + $wcscmp_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +180 +__lo_t + +__loc + +__THROW +; + +182  + $wccmp_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +183 +size_t + +__n +, +__lo_t + +__loc + +__THROW +; + +186 +__BEGIN_NAMESPACE_STD + + +189  + $wcscl + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 + +__THROW +; + +193 +size_t + + $wcsxm + ( +wch_t + * +__ri + +__s1 +, + +194 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n + +__THROW +; + +195 +__END_NAMESPACE_STD + + +197 #ifde +__USE_XOPEN2K8 + + +203  + $wcscl_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +204 +__lo_t + +__loc + +__THROW +; + +209 +size_t + + $wcsxm_l + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, + +210 +size_t + +__n +, +__lo_t + +__loc + +__THROW +; + +213 +wch_t + * + $wcsdup + ( +__cڡ + +wch_t + * +__s + +__THROW + +__ibu_mloc__ +; + +216 +__BEGIN_NAMESPACE_STD + + +218 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +219 "C++" +wch_t + * + $wcschr + ( +wch_t + * +__wcs +, wch_ +__wc +) + +220 +__THROW + + `__asm + ("wcschr" +__ibu_pu__ +; + +221 "C++" +__cڡ + +wch_t + * + $wcschr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +222 +__THROW + + `__asm + ("wcschr" +__ibu_pu__ +; + +224 +wch_t + * + $wcschr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +225 +__THROW + +__ibu_pu__ +; + +228 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +229 "C++" +wch_t + * + $wcchr + ( +wch_t + * +__wcs +, wch_ +__wc +) + +230 +__THROW + + `__asm + ("wcchr" +__ibu_pu__ +; + +231 "C++" +__cڡ + +wch_t + * + $wcchr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +232 +__THROW + + `__asm + ("wcchr" +__ibu_pu__ +; + +234 +wch_t + * + $wcchr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +235 +__THROW + +__ibu_pu__ +; + +237 +__END_NAMESPACE_STD + + +239 #ifde +__USE_GNU + + +242 +wch_t + * + $wcschul + ( +__cڡ + +wch_t + * +__s +, wch_ +__wc +) + +243 +__THROW + +__ibu_pu__ +; + +246 +__BEGIN_NAMESPACE_STD + + +249 +size_t + + $wcscn + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__je +) + +250 +__THROW + +__ibu_pu__ +; + +253 +size_t + + $wcsn + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__ac +) + +254 +__THROW + +__ibu_pu__ +; + +256 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +257 "C++" +wch_t + * + $wcbrk + ( +wch_t + * +__wcs +, +__cڡ + wch_* +__ac +) + +258 +__THROW + + `__asm + ("wcbrk" +__ibu_pu__ +; + +259 "C++" +__cڡ + +wch_t + * + $wcbrk + ( +__cڡ + +wch_t + * +__wcs +, + +260 +__cڡ + +wch_t + * +__ac +) + +261 +__THROW + + `__asm + ("wcbrk" +__ibu_pu__ +; + +263 +wch_t + * + $wcbrk + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__ac +) + +264 +__THROW + +__ibu_pu__ +; + +267 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +268 "C++" +wch_t + * + $wcsr + ( +wch_t + * +__hayack +, +__cڡ + wch_* +__ed +) + +269 +__THROW + + `__asm + ("wcsr" +__ibu_pu__ +; + +270 "C++" +__cڡ + +wch_t + * + $wcsr + ( +__cڡ + +wch_t + * +__hayack +, + +271 +__cڡ + +wch_t + * +__ed +) + +272 +__THROW + + `__asm + ("wcsr" +__ibu_pu__ +; + +274 +wch_t + * + $wcsr + ( +__cڡ + +wch_t + * +__hayack +, __cڡ wch_* +__ed +) + +275 +__THROW + +__ibu_pu__ +; + +279 +wch_t + * + $wcok + ( +wch_t + * +__ri + +__s +, + +280 +__cڡ + +wch_t + * +__ri + +__dim +, + +281 +wch_t + ** +__ri + +__r + +__THROW +; + +284 +size_t + + $wc + ( +__cڡ + +wch_t + * +__s + +__THROW + +__ibu_pu__ +; + +285 +__END_NAMESPACE_STD + + +287 #ifde +__USE_XOPEN + + +289 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +290 "C++" +wch_t + * + $wcswcs + ( +wch_t + * +__hayack +, +__cڡ + wch_* +__ed +) + +291 +__THROW + + `__asm + ("wcswcs" +__ibu_pu__ +; + +292 "C++" +__cڡ + +wch_t + * + $wcswcs + ( +__cڡ + +wch_t + * +__hayack +, + +293 +__cڡ + +wch_t + * +__ed +) + +294 +__THROW + + `__asm + ("wcswcs" +__ibu_pu__ +; + +296 +wch_t + * + $wcswcs + ( +__cڡ + +wch_t + * +__hayack +, __cڡ wch_* +__ed +) + +297 +__THROW + +__ibu_pu__ +; + +301 #ifde +__USE_XOPEN2K8 + + +303 +size_t + + $wcn + ( +__cڡ + +wch_t + * +__s +, +size_t + +__maxn +) + +304 +__THROW + +__ibu_pu__ +; + +308 +__BEGIN_NAMESPACE_STD + + +310 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +311 "C++" +wch_t + * + $wmemchr + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +) + +312 +__THROW + + `__asm + ("wmemchr" +__ibu_pu__ +; + +313 "C++" +__cڡ + +wch_t + * + $wmemchr + ( +__cڡ + +wch_t + * +__s +, wch_ +__c +, + +314 +size_t + +__n +) + +315 +__THROW + + `__asm + ("wmemchr" +__ibu_pu__ +; + +317 +wch_t + * + $wmemchr + ( +__cڡ + +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +) + +318 +__THROW + +__ibu_pu__ +; + +322  + $wmemcmp + ( +__cڡ + +wch_t + * +__ri + +__s1 +, + +323 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +) + +324 +__THROW + +__ibu_pu__ +; + +327 +wch_t + * + $wmemy + ( +wch_t + * +__ri + +__s1 +, + +328 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n + +__THROW +; + +332 +wch_t + * + $wmemmove + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, +size_t + +__n +) + +333 +__THROW +; + +336 +wch_t + * + $wmemt + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n + +__THROW +; + +337 +__END_NAMESPACE_STD + + +339 #ifde +__USE_GNU + + +342 +wch_t + * + $wmempy + ( +wch_t + * +__ri + +__s1 +, + +343 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +) + +344 +__THROW +; + +348 +__BEGIN_NAMESPACE_STD + + +351 +wt_t + + $btowc + ( +__c + +__THROW +; + +355  + $wob + ( +wt_t + +__c + +__THROW +; + +359  + $mbs + ( +__cڡ + +mbe_t + * +__ps + +__THROW + +__ibu_pu__ +; + +363 +size_t + + $mbowc + ( +wch_t + * +__ri + +__pwc +, + +364 +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +365 +mbe_t + * +__p + +__THROW +; + +368 +size_t + + $wtomb + (* +__ri + +__s +, +wch_t + +__wc +, + +369 +mbe_t + * +__ri + +__ps + +__THROW +; + +372 +size_t + + $__mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +373 +mbe_t + * +__ri + +__ps + +__THROW +; + +374 +size_t + + $mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +375 +mbe_t + * +__ri + +__ps + +__THROW +; + +376 +__END_NAMESPACE_STD + + +378 #ifde +__USE_EXTERN_INLINES + + +384 +wt_t + + $__btowc_s + ( +__c + + `__asm + ("btowc"); + +385 +__ex_le + +wt_t + + +386 + `__NTH + ( + $btowc + ( +__c +)) + +387 {  ( + `__but_cڡt_p + ( +__c +) && __c >= '\0' && __c <= '\x7f' + +388 ? ( +wt_t + +__c + : + `__btowc_s + (__c)); + } +} + +390  + $__wob_s + ( +wt_t + +__c + + `__asm + ("wctob"); + +391 +__ex_le +  + +392 + `__NTH + ( + $wob + ( +wt_t + +__wc +)) + +393 {  ( + `__but_cڡt_p + ( +__wc +&& __w> +L +'\0' && __wc <= L'\x7f' + +394 ? ( +__wc + : + `__wob_s + (__wc)); + } +} + +396 +__ex_le + +size_t + + +397 +__NTH + ( + $mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +398 +mbe_t + * +__ri + +__ps +)) + +399 {  ( +__ps + ! +NULL + + +400 ? + `mbowc + ( +NULL +, +__s +, +__n +, +__ps +: + `__mb + (__s, __n, NULL)); + } +} + +403 +__BEGIN_NAMESPACE_STD + + +406 +size_t + + $mbtowcs + ( +wch_t + * +__ri + +__d +, + +407 +__cڡ + ** +__ri + +__c +, +size_t + +__n +, + +408 +mbe_t + * +__ri + +__ps + +__THROW +; + +412 +size_t + + $wctombs + (* +__ri + +__d +, + +413 +__cڡ + +wch_t + ** +__ri + +__c +, +size_t + +__n +, + +414 +mbe_t + * +__ri + +__ps + +__THROW +; + +415 +__END_NAMESPACE_STD + + +418 #ifdef +__USE_XOPEN2K8 + + +421 +size_t + + $mbowcs + ( +wch_t + * +__ri + +__d +, + +422 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +423 +size_t + +__n +, +mbe_t + * +__ri + +__ps + +__THROW +; + +427 +size_t + + $wcombs + (* +__ri + +__d +, + +428 +__cڡ + +wch_t + ** +__ri + +__c +, + +429 +size_t + +__nwc +, size_ +__n +, + +430 +mbe_t + * +__ri + +__ps + +__THROW +; + +435 #ifde +__USE_XOPEN + + +437  + $wcwidth + ( +wch_t + +__c + +__THROW +; + +441  + $wcswidth + ( +__cڡ + +wch_t + * +__s +, +size_t + +__n + +__THROW +; + +445 +__BEGIN_NAMESPACE_STD + + +448  + $wcod + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +449 +wch_t + ** +__ri + +__dr + +__THROW +; + +450 +__END_NAMESPACE_STD + + +452 #ifde +__USE_ISOC99 + + +453 +__BEGIN_NAMESPACE_C99 + + +455  + $wcof + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +456 +wch_t + ** +__ri + +__dr + +__THROW +; + +457  + $wcd + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +458 +wch_t + ** +__ri + +__dr + +__THROW +; + +459 +__END_NAMESPACE_C99 + + +463 +__BEGIN_NAMESPACE_STD + + +466  + $wc + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +467 +wch_t + ** +__ri + +__dr +,  +__ba + +__THROW +; + +471  + $wcoul + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +472 +wch_t + ** +__ri + +__dr +,  +__ba +) + +473 +__THROW +; + +474 +__END_NAMESPACE_STD + + +476 #i +defed + +__USE_ISOC99 + || (defed +__GNUC__ + && defed +__USE_GNU +) + +477 +__BEGIN_NAMESPACE_C99 + + +480 +__exnsi__ + + +481  + $wcl + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +482 +wch_t + ** +__ri + +__dr +,  +__ba +) + +483 +__THROW +; + +487 +__exnsi__ + + +488  + $wcou + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +489 +wch_t + ** +__ri + +__dr +, + +490  +__ba + +__THROW +; + +491 +__END_NAMESPACE_C99 + + +494 #i +defed + +__GNUC__ + && defed +__USE_GNU + + +497 +__exnsi__ + + +498  + $wcoq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +499 +wch_t + ** +__ri + +__dr +,  +__ba +) + +500 +__THROW +; + +504 +__exnsi__ + + +505  + $wcouq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +506 +wch_t + ** +__ri + +__dr +, + +507  +__ba + +__THROW +; + +510 #ifde +__USE_GNU + + +524  + ~ + +528  + $wc_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +529 +wch_t + ** +__ri + +__dr +,  +__ba +, + +530 +__lo_t + +__loc + +__THROW +; + +532  + $wcoul_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +533 +wch_t + ** +__ri + +__dr +, + +534  +__ba +, +__lo_t + +__loc + +__THROW +; + +536 +__exnsi__ + + +537  + $wcl_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +538 +wch_t + ** +__ri + +__dr +, + +539  +__ba +, +__lo_t + +__loc + +__THROW +; + +541 +__exnsi__ + + +542  + $wcou_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +543 +wch_t + ** +__ri + +__dr +, + +544  +__ba +, +__lo_t + +__loc +) + +545 +__THROW +; + +547  + $wcod_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +548 +wch_t + ** +__ri + +__dr +, +__lo_t + +__loc +) + +549 +__THROW +; + +551  + $wcof_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +552 +wch_t + ** +__ri + +__dr +, +__lo_t + +__loc +) + +553 +__THROW +; + +555  + $wcd_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +556 +wch_t + ** +__ri + +__dr +, + +557 +__lo_t + +__loc + +__THROW +; + +561 #ifdef +__USE_XOPEN2K8 + + +564 +wch_t + * + $wy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c + +__THROW +; + +568 +wch_t + * + $wny + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +) + +569 +__THROW +; + +575 #ifdef +__USE_XOPEN2K8 + + +578 +__FILE + * + $ݒ_wmemam + ( +wch_t + ** +__buoc +, +size_t + * +__sizoc + +__THROW +; + +581 #i +defed + +__USE_ISOC95 + || defed +__USE_UNIX98 + + +582 +__BEGIN_NAMESPACE_STD + + +585  + $fwide + ( +__FILE + * +__ +,  +__mode + +__THROW +; + +592  + `fwtf + ( +__FILE + * +__ri + +__am +, + +593 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +599  + `wtf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +602  + $swtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +603 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +604 +__THROW + ; + +610  + `vfwtf + ( +__FILE + * +__ri + +__s +, + +611 +__cڡ + +wch_t + * +__ri + +__fm +, + +612 +__gnuc_va_li + +__g +) + +618  + `vwtf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +619 +__gnuc_va_li + +__g +) + +623  + $vswtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +624 +__cڡ + +wch_t + * +__ri + +__fm +, + +625 +__gnuc_va_li + +__g +) + +626 +__THROW + ; + +633  + `fwsnf + ( +__FILE + * +__ri + +__am +, + +634 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +640  + `wsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +643  + $swsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +644 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +645 +__THROW + ; + +647 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +648 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +649 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +650 #ifde +__REDIRECT + + +654  + `__REDIRECT + ( +fwsnf +, ( +__FILE + * +__ri + +__am +, + +655 +__cڡ + +wch_t + * +__ri + +__fm +, ...), + +656 +__isoc99_fwsnf +) + +658  + `__REDIRECT + ( +wsnf +, ( +__cڡ + +wch_t + * +__ri + +__fm +, ...), + +659 +__isoc99_wsnf +) + +661  + `__REDIRECT + ( +swsnf +, ( +__cڡ + +wch_t + * +__ri + +__s +, + +662 +__cڡ + +wch_t + * +__ri + +__fm +, ...), + +663 +__isoc99_swsnf +) + +664 +__THROW + ; + +666  + `__isoc99_fwsnf + ( +__FILE + * +__ri + +__am +, + +667 +__cڡ + +wch_t + * +__ri + +__fm +, ...); + +668  + `__isoc99_wsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...); + +669  + $__isoc99_swsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +670 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +671 +__THROW +; + +672  + #fwsnf + +__isoc99_fwsnf + + + ) + +673  + #wsnf + +__isoc99_wsnf + + + ) + +674  + #swsnf + +__isoc99_swsnf + + + ) + +678 +__END_NAMESPACE_STD + + +681 #ifde +__USE_ISOC99 + + +682 +__BEGIN_NAMESPACE_C99 + + +687  + `vfwsnf + ( +__FILE + * +__ri + +__s +, + +688 +__cڡ + +wch_t + * +__ri + +__fm +, + +689 +__gnuc_va_li + +__g +) + +695  + `vwsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +696 +__gnuc_va_li + +__g +) + +699  + $vswsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +700 +__cڡ + +wch_t + * +__ri + +__fm +, + +701 +__gnuc_va_li + +__g +) + +702 +__THROW + ; + +704 #i! +defed + +__USE_GNU + \ + +705 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +706 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +707 #ifde +__REDIRECT + + +708  + `__REDIRECT + ( +vfwsnf +, ( +__FILE + * +__ri + +__s +, + +709 +__cڡ + +wch_t + * +__ri + +__fm +, + +710 +__gnuc_va_li + +__g +), +__isoc99_vfwsnf +) + +712  + `__REDIRECT + ( +vwsnf +, ( +__cڡ + +wch_t + * +__ri + +__fm +, + +713 +__gnuc_va_li + +__g +), +__isoc99_vwsnf +) + +715  + `__REDIRECT + ( +vswsnf +, ( +__cڡ + +wch_t + * +__ri + +__s +, + +716 +__cڡ + +wch_t + * +__ri + +__fm +, + +717 +__gnuc_va_li + +__g +), +__isoc99_vswsnf +) + +718 +__THROW + ; + +720  + `__isoc99_vfwsnf + ( +__FILE + * +__ri + +__s +, + +721 +__cڡ + +wch_t + * +__ri + +__fm +, + +722 +__gnuc_va_li + +__g +); + +723  + `__isoc99_vwsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +724 +__gnuc_va_li + +__g +); + +725  + $__isoc99_vswsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +726 +__cڡ + +wch_t + * +__ri + +__fm +, + +727 +__gnuc_va_li + +__g + +__THROW +; + +728  + #vfwsnf + +__isoc99_vfwsnf + + + ) + +729  + #vwsnf + +__isoc99_vwsnf + + + ) + +730  + #vswsnf + +__isoc99_vswsnf + + + ) + +734 +__END_NAMESPACE_C99 + + +738 +__BEGIN_NAMESPACE_STD + + +743 +wt_t + + `fgwc + ( +__FILE + * +__am +); + +744 +wt_t + + `gwc + ( +__FILE + * +__am +); + +750 +wt_t + + `gwch + (); + +757 +wt_t + + `utwc + ( +wch_t + +__wc +, +__FILE + * +__am +); + +758 +wt_t + + `putwc + ( +wch_t + +__wc +, +__FILE + * +__am +); + +764 +wt_t + + `putwch + ( +wch_t + +__wc +); + +772 +wch_t + * + `fgws + (wch_* +__ri + +__ws +,  +__n +, + +773 +__FILE + * +__ri + +__am +); + +779  + `utws + ( +__cڡ + +wch_t + * +__ri + +__ws +, + +780 +__FILE + * +__ri + +__am +); + +787 +wt_t + + `ungwc + (wt_ +__wc +, +__FILE + * +__am +); + +788 +__END_NAMESPACE_STD + + +791 #ifde +__USE_GNU + + +799 +wt_t + + `gwc_uocked + ( +__FILE + * +__am +); + +800 +wt_t + + `gwch_uocked + (); + +808 +wt_t + + `fgwc_uocked + ( +__FILE + * +__am +); + +816 +wt_t + + `utwc_uocked + ( +wch_t + +__wc +, +__FILE + * +__am +); + +825 +wt_t + + `putwc_uocked + ( +wch_t + +__wc +, +__FILE + * +__am +); + +826 +wt_t + + `putwch_uocked + ( +wch_t + +__wc +); + +835 +wch_t + * + `fgws_uocked + (wch_* +__ri + +__ws +,  +__n +, + +836 +__FILE + * +__ri + +__am +); + +844  + `utws_uocked + ( +__cڡ + +wch_t + * +__ri + +__ws +, + +845 +__FILE + * +__ri + +__am +); + +849 +__BEGIN_NAMESPACE_C99 + + +853 +size_t + + $wcsime + ( +wch_t + * +__ri + +__s +, +size_t + +__maxsize +, + +854 +__cڡ + +wch_t + * +__ri + +__fm +, + +855 +__cڡ +  +tm + * +__ri + +__ + +__THROW +; + +856 +__END_NAMESPACE_C99 + + +858 #ifde +__USE_GNU + + +859  + ~ + +863 +size_t + + $wcsime_l + ( +wch_t + * +__ri + +__s +, +size_t + +__maxsize +, + +864 +__cڡ + +wch_t + * +__ri + +__fm +, + +865 +__cڡ +  +tm + * +__ri + +__ +, + +866 +__lo_t + +__loc + +__THROW +; + +875 #i +defed + +__USE_UNIX98 + && !defed +__USE_GNU + + +876  + #__ed_iswxxx + + + ) + +877  + ~ + +881 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +882  + ~ + +885 #ifde +__LDBL_COMPAT + + +886  + ~ + +889 +__END_DECLS + + +897 #unde +__ed_mbe_t + + +898 #unde +__ed_wt_t + + + @/usr/include/xlocale.h + +21 #ide +_XLOCALE_H + + +22  + #_XLOCALE_H + 1 + + ) + +28  + s__lo_ru + + +31  +lo_da + * + m__los +[13]; + +34 cڡ * + m__y_b +; + +35 cڡ * + m__y_tow +; + +36 cڡ * + m__y_tou +; + +39 cڡ * + m__mes +[13]; + +40 } * + t__lo_t +; + +43  +__lo_t + + tlo_t +; + + @/usr/include/bits/byteswap.h + +21 #i! +defed + +_BYTESWAP_H + && !defed +_NETINET_IN_H + && !defed +_ENDIAN_H + + +25 #ide +_BITS_BYTESWAP_H + + +26  + #_BITS_BYTESWAP_H + 1 + + ) + +28  + ~ + +31  + #__bsw_cڡt_16 +( +x +) \ + +32 (((( +x +>> 8& 0xff| (((x& 0xff<< 8)) + + ) + +34 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +35  + #__bsw_16 +( +x +) \ + +36 ( +__exnsi__ + \ + +37 ({  +__v +, +__x + = ( +x +); \ + +38 i( + `__but_cڡt_p + ( +__x +)) \ + +39 +__v + = + `__bsw_cڡt_16 + ( +__x +); \ + +41 + `__asm__ + ("rorw $8, %w0" \ + +42 : "" ( +__v +) \ + +43 : "0" ( +__x +) \ + +45 +__v +; })) + + ) + +48  + #__bsw_16 +( +x +) \ + +49 ( +__exnsi__ + \ + +50 ({  +__x + = ( +x +); + `__bsw_cڡt_16 + (__x); })) + + ) + +55  + #__bsw_cڡt_32 +( +x +) \ + +56 (((( +x +) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + +57 ((( +x +& 0x0000ff00<< 8| (((x& 0x000000ff<< 24)) + + ) + +59 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +60 #i +__WORDSIZE + =64 || ( +defed + +__i486__ + || defed +__ium__ + \ + +61 || +defed + + g__iumo__ + || defed + g__ium4__ + \ + +62 || +defed + + g__k8__ + || defed + g__hl__ + \ + +63 || +defed + + g__k6__ + || defed + g__noca__ + \ + +64 || +defed + + g__ce2__ + || defed + g__geode__ + \ + +65 || +defed + + g__amdm10__ +) + +68  + #__bsw_32 +( +x +) \ + +69 ( +__exnsi__ + \ + +70 ({  +__v +, +__x + = ( +x +); \ + +71 i( + `__but_cڡt_p + ( +__x +)) \ + +72 +__v + = + `__bsw_cڡt_32 + ( +__x +); \ + +74 + `__asm__ + ("bsw %0" : "" ( +__v +: "0" ( +__x +)); \ + +75 +__v +; })) + + ) + +77  + #__bsw_32 +( +x +) \ + +78 ( +__exnsi__ + \ + +79 ({  +__v +, +__x + = ( +x +); \ + +80 i( + `__but_cڡt_p + ( +__x +)) \ + +81 +__v + = + `__bsw_cڡt_32 + ( +__x +); \ + +83 + `__asm__ + ("rorw $8, %w0;" \ + +86 : "" ( +__v +) \ + +87 : "0" ( +__x +) \ + +89 +__v +; })) + + ) + +92  + #__bsw_32 +( +x +) \ + +93 ( +__exnsi__ + \ + +94 ({  +__x + = ( +x +); + `__bsw_cڡt_32 + (__x); })) + + ) + +98 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +100  + #__bsw_cڡt_64 +( +x +) \ + +101 (((( +x +) & 0xff00000000000000ull) >> 56) \ + +102 | ((( +x +) & 0x00ff000000000000ull) >> 40) \ + +103 | ((( +x +) & 0x0000ff0000000000ull) >> 24) \ + +104 | ((( +x +) & 0x000000ff00000000ull) >> 8) \ + +105 | ((( +x +) & 0x00000000ff000000ull) << 8) \ + +106 | ((( +x +) & 0x0000000000ff0000ull) << 24) \ + +107 | ((( +x +) & 0x000000000000ff00ull) << 40) \ + +108 | ((( +x +& 0x00000000000000ffu<< 56)) + + ) + +110 #i +__WORDSIZE + == 64 + +111  + #__bsw_64 +( +x +) \ + +112 ( +__exnsi__ + \ + +113 ({  +__v +, +__x + = ( +x +); \ + +114 i( + `__but_cڡt_p + ( +__x +)) \ + +115 +__v + = + `__bsw_cڡt_64 + ( +__x +); \ + +117 + `__asm__ + ("bsw %q0" : "" ( +__v +: "0" ( +__x +)); \ + +118 +__v +; })) + + ) + +120  + #__bsw_64 +( +x +) \ + +121 ( +__exnsi__ + \ + +122 ({ uni { +__exnsi__ +  +__ +; \ + +123  +__l +[2]; } +__w +, +__r +; \ + +124 i( + `__but_cڡt_p + ( +x +)) \ + +125 +__r +. +__ + = + `__bsw_cڡt_64 + ( +x +); \ + +128 +__w +. +__ + = ( +x +); \ + +129 +__r +. +__l +[0] = + `__bsw_32 + ( +__w +.__l[1]); \ + +130 +__r +. +__l +[1] = + `__bsw_32 + ( +__w +.__l[0]); \ + +132 +__r +. +__ +; })) + + ) + + @/usr/include/bits/endian.h + +3 #ide +_ENDIAN_H + + +7  + #__BYTE_ORDER + +__LITTLE_ENDIAN + + + ) + + @/usr/include/bits/wchar-ldbl.h + +20 #ide +_WCHAR_H + + +24 #i +defed + +__USE_ISOC95 + || defed +__USE_UNIX98 + + +25 +__BEGIN_NAMESPACE_C99 + + +26 +__LDBL_REDIR_DECL + ( +fwtf +); + +27 +__LDBL_REDIR_DECL + ( +wtf +); + +28 +__LDBL_REDIR_DECL + ( +swtf +); + +29 +__LDBL_REDIR_DECL + ( +vfwtf +); + +30 +__LDBL_REDIR_DECL + ( +vwtf +); + +31 +__LDBL_REDIR_DECL + ( +vswtf +); + +32 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +33 && ! +defed + + g__REDIRECT + \ + +34 && ( +defed + + g__STRICT_ANSI__ + || defed + g__USE_XOPEN2K +) + +35 + $__LDBL_REDIR1_DECL + ( +fwsnf +, +__dbl___isoc99_fwsnf +) + +36 + $__LDBL_REDIR1_DECL + ( +wsnf +, +__dbl___isoc99_wsnf +) + +37 + $__LDBL_REDIR1_DECL + ( +swsnf +, +__dbl___isoc99_swsnf +) + +39 + `__LDBL_REDIR_DECL + ( +fwsnf +); + +40 + `__LDBL_REDIR_DECL + ( +wsnf +); + +41 + `__LDBL_REDIR_DECL + ( +swsnf +); + +43 +__END_NAMESPACE_C99 + + +46 #ifde +__USE_ISOC99 + + +47 +__BEGIN_NAMESPACE_C99 + + +48 + `__LDBL_REDIR1_DECL + ( +wcd +, +wcod +); + +49 #i! +defed + +__USE_GNU + && !defed +__REDIRECT + \ + +50 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +51 + $__LDBL_REDIR1_DECL + ( +vfwsnf +, +__dbl___isoc99_vfwsnf +) + +52 + $__LDBL_REDIR1_DECL + ( +vwsnf +, +__dbl___isoc99_vwsnf +) + +53 + $__LDBL_REDIR1_DECL + ( +vswsnf +, +__dbl___isoc99_vswsnf +) + +55 + `__LDBL_REDIR_DECL + ( +vfwsnf +); + +56 + `__LDBL_REDIR_DECL + ( +vwsnf +); + +57 + `__LDBL_REDIR_DECL + ( +vswsnf +); + +59 +__END_NAMESPACE_C99 + + +62 #ifde +__USE_GNU + + +63 + `__LDBL_REDIR1_DECL + ( +wcd_l +, +wcod_l +); + +66 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +67 + $__LDBL_REDIR_DECL + ( +__swtf_chk +) + +68 + $__LDBL_REDIR_DECL + ( +__vswtf_chk +) + +69 #i +__USE_FORTIFY_LEVEL + > 1 + +70 + $__LDBL_REDIR_DECL + ( +__fwtf_chk +) + +71 + $__LDBL_REDIR_DECL + ( +__wtf_chk +) + +72 + $__LDBL_REDIR_DECL + ( +__vfwtf_chk +) + +73 + $__LDBL_REDIR_DECL + ( +__vwtf_chk +) + + @/usr/include/bits/wchar.h + +20 #ide +_BITS_WCHAR_H + + +21  + #_BITS_WCHAR_H + 1 + + ) + +24 #ifde +__WCHAR_MAX__ + + +25  + #__WCHAR_MAX + +__WCHAR_MAX__ + + + ) + +27  + #__WCHAR_MAX + (2147483647) + + ) + +32 #ifde +__WCHAR_UNSIGNED__ + + +33  + #__WCHAR_MIN + +L +'\0' + + ) + +37 #i +L +'\0' - 1 > 0 + +38  + #__WCHAR_MIN + +L +'\0' + + ) + +40  + #__WCHAR_MIN + (- +__WCHAR_MAX + - 1) + + ) + + @/usr/include/bits/wchar2.h + +20 #ide +_WCHAR_H + + +25 +wch_t + * + $__wmemy_chk + ( +wch_t + * +__ri + +__s1 +, + +26 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +27 +size_t + +__ns1 + +__THROW +; + +28 +wch_t + * + `__REDIRECT_NTH + ( +__wmemy_s +, + +29 ( +wch_t + * +__ri + +__s1 +, + +30 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +), + +31 +wmemy +); + +32 +wch_t + * + `__REDIRECT_NTH + ( +__wmemy_chk_wn +, + +33 ( +wch_t + * +__ri + +__s1 +, + +34 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +35 +size_t + +__ns1 +), +__wmemy_chk +) + +36 + `__wljr + ("wmemcpy called withength biggerhan size of destination " + +39 +__ex_ways_le + +wch_t + * + +40 + `__NTH + ( + $wmemy + ( +wch_t + * +__ri + +__s1 +, +__cڡ + wch_*__ri +__s2 +, + +41 +size_t + +__n +)) + +43 i( + `__bos0 + ( +__s1 +!( +size_t +) -1) + +45 i(! + `__but_cڡt_p + ( +__n +)) + +46  + `__wmemy_chk + ( +__s1 +, +__s2 +, +__n +, + +47 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +49 i( +__n + > + `__bos0 + ( +__s1 +/  ( +wch_t +)) + +50  + `__wmemy_chk_wn + ( +__s1 +, +__s2 +, +__n +, + +51 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +53  + `__wmemy_s + ( +__s1 +, +__s2 +, +__n +); + +54 + } +} + +57 +wch_t + * + $__wmemmove_chk + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, + +58 +size_t + +__n +, size_ +__ns1 + +__THROW +; + +59 +wch_t + * + `__REDIRECT_NTH + ( +__wmemmove_s +, (wch_* +__s1 +, + +60 +__cڡ + +wch_t + * +__s2 +, + +61 +size_t + +__n +), +wmemmove +); + +62 +wch_t + * + `__REDIRECT_NTH + ( +__wmemmove_chk_wn +, + +63 ( +wch_t + * +__ri + +__s1 +, + +64 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +65 +size_t + +__ns1 +), +__wmemmove_chk +) + +66 + `__wljr + ("wmemmove called withength biggerhan size of destination " + +69 +__ex_ways_le + +wch_t + * + +70 + `__NTH + ( + $wmemmove + ( +wch_t + * +__ri + +__s1 +, +__cڡ + wch_*__ri +__s2 +, + +71 +size_t + +__n +)) + +73 i( + `__bos0 + ( +__s1 +!( +size_t +) -1) + +75 i(! + `__but_cڡt_p + ( +__n +)) + +76  + `__wmemmove_chk + ( +__s1 +, +__s2 +, +__n +, + +77 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +79 i( +__n + > + `__bos0 + ( +__s1 +/  ( +wch_t +)) + +80  + `__wmemmove_chk_wn + ( +__s1 +, +__s2 +, +__n +, + +81 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +83  + `__wmemmove_s + ( +__s1 +, +__s2 +, +__n +); + +84 + } +} + +87 #ifde +__USE_GNU + + +88 +wch_t + * + $__wmempy_chk + ( +wch_t + * +__ri + +__s1 +, + +89 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +90 +size_t + +__ns1 + +__THROW +; + +91 +wch_t + * + `__REDIRECT_NTH + ( +__wmempy_s +, + +92 ( +wch_t + * +__ri + +__s1 +, + +93 +__cڡ + +wch_t + * +__ri + +__s2 +, + +94 +size_t + +__n +), +wmempy +); + +95 +wch_t + * + `__REDIRECT_NTH + ( +__wmempy_chk_wn +, + +96 ( +wch_t + * +__ri + +__s1 +, + +97 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +98 +size_t + +__ns1 +), +__wmempy_chk +) + +99 + `__wljr + ("wmempcpy called withength biggerhan size of destination " + +102 +__ex_ways_le + +wch_t + * + +103 + `__NTH + ( + $wmempy + ( +wch_t + * +__ri + +__s1 +, +__cڡ + wch_*__ri +__s2 +, + +104 +size_t + +__n +)) + +106 i( + `__bos0 + ( +__s1 +!( +size_t +) -1) + +108 i(! + `__but_cڡt_p + ( +__n +)) + +109  + `__wmempy_chk + ( +__s1 +, +__s2 +, +__n +, + +110 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +112 i( +__n + > + `__bos0 + ( +__s1 +/  ( +wch_t +)) + +113  + `__wmempy_chk_wn + ( +__s1 +, +__s2 +, +__n +, + +114 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +116  + `__wmempy_s + ( +__s1 +, +__s2 +, +__n +); + +117 + } +} + +121 +wch_t + * + $__wmemt_chk + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +, + +122 +size_t + +__ns + +__THROW +; + +123 +wch_t + * + `__REDIRECT_NTH + ( +__wmemt_s +, (wch_* +__s +, wch_ +__c +, + +124 +size_t + +__n +), +wmemt +); + +125 +wch_t + * + `__REDIRECT_NTH + ( +__wmemt_chk_wn +, + +126 ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +, + +127 +size_t + +__ns +), +__wmemt_chk +) + +128 + `__wljr + ("wmemset called withength biggerhan size of destination " + +131 +__ex_ways_le + +wch_t + * + +132 + `__NTH + ( + $wmemt + ( +wch_t + * +__ri + +__s +, wch_ +__c +, +size_t + +__n +)) + +134 i( + `__bos0 + ( +__s +!( +size_t +) -1) + +136 i(! + `__but_cڡt_p + ( +__n +)) + +137  + `__wmemt_chk + ( +__s +, +__c +, +__n +, + `__bos0 + (__s/  ( +wch_t +)); + +139 i( +__n + > + `__bos0 + ( +__s +/  ( +wch_t +)) + +140  + `__wmemt_chk_wn + ( +__s +, +__c +, +__n +, + +141 + `__bos0 + ( +__s +/  ( +wch_t +)); + +143  + `__wmemt_s + ( +__s +, +__c +, +__n +); + +144 + } +} + +147 +wch_t + * + $__wcsy_chk + ( +wch_t + * +__ri + +__de +, + +148 +__cڡ + +wch_t + * +__ri + +__c +, + +149 +size_t + +__n + +__THROW +; + +150 +wch_t + * + `__REDIRECT_NTH + ( +__wcsy_s +, + +151 ( +wch_t + * +__ri + +__de +, + +152 +__cڡ + +wch_t + * +__ri + +__c +), +wcsy +); + +154 +__ex_ways_le + +wch_t + * + +155 + `__NTH + ( + $wcsy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +)) + +157 i( + `__bos + ( +__de +!( +size_t +) -1) + +158  + `__wcsy_chk + ( +__de +, +__c +, + `__bos + (__de/  ( +wch_t +)); + +159  + `__wcsy_s + ( +__de +, +__c +); + +160 + } +} + +163 +wch_t + * + $__wy_chk + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, + +164 +size_t + +__den + +__THROW +; + +165 +wch_t + * + `__REDIRECT_NTH + ( +__wy_s +, (wch_* +__de +, + +166 +__cڡ + +wch_t + * +__c +), + +167 +wy +); + +169 +__ex_ways_le + +wch_t + * + +170 + `__NTH + ( + $wy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +)) + +172 i( + `__bos + ( +__de +!( +size_t +) -1) + +173  + `__wy_chk + ( +__de +, +__c +, + `__bos + (__de/  ( +wch_t +)); + +174  + `__wy_s + ( +__de +, +__c +); + +175 + } +} + +178 +wch_t + * + $__wcy_chk + ( +wch_t + * +__ri + +__de +, + +179 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +, + +180 +size_t + +__den + +__THROW +; + +181 +wch_t + * + `__REDIRECT_NTH + ( +__wcy_s +, + +182 ( +wch_t + * +__ri + +__de +, + +183 +__cڡ + +wch_t + * +__ri + +__c +, + +184 +size_t + +__n +), +wcy +); + +185 +wch_t + * + `__REDIRECT_NTH + ( +__wcy_chk_wn +, + +186 ( +wch_t + * +__ri + +__de +, + +187 +__cڡ + +wch_t + * +__ri + +__c +, + +188 +size_t + +__n +, size_ +__den +), +__wcy_chk +) + +189 + `__wljr + ("wcsncpy called withength biggerhan size of destination " + +192 +__ex_ways_le + +wch_t + * + +193 + `__NTH + ( + $wcy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +)) + +195 i( + `__bos + ( +__de +!( +size_t +) -1) + +197 i(! + `__but_cڡt_p + ( +__n +)) + +198  + `__wcy_chk + ( +__de +, +__c +, +__n +, + +199 + `__bos + ( +__de +/  ( +wch_t +)); + +200 i( +__n + > + `__bos + ( +__de +/  ( +wch_t +)) + +201  + `__wcy_chk_wn + ( +__de +, +__c +, +__n +, + +202 + `__bos + ( +__de +/  ( +wch_t +)); + +204  + `__wcy_s + ( +__de +, +__c +, +__n +); + +205 + } +} + +208 +wch_t + * + $__wny_chk + ( +wch_t + * +__ri + +__de +, + +209 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +, + +210 +size_t + +__den + +__THROW +; + +211 +wch_t + * + `__REDIRECT_NTH + ( +__wny_s +, + +212 ( +wch_t + * +__ri + +__de +, + +213 +__cڡ + +wch_t + * +__ri + +__c +, + +214 +size_t + +__n +), +wny +); + +215 +wch_t + * + `__REDIRECT_NTH + ( +__wny_chk_wn +, + +216 ( +wch_t + * +__ri + +__de +, + +217 +__cڡ + +wch_t + * +__ri + +__c +, + +218 +size_t + +__n +, size_ +__den +), +__wny_chk +) + +219 + `__wljr + ("wcpncpy called withength biggerhan size of destination " + +222 +__ex_ways_le + +wch_t + * + +223 + `__NTH + ( + $wny + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +)) + +225 i( + `__bos + ( +__de +!( +size_t +) -1) + +227 i(! + `__but_cڡt_p + ( +__n +)) + +228  + `__wny_chk + ( +__de +, +__c +, +__n +, + +229 + `__bos + ( +__de +/  ( +wch_t +)); + +230 i( +__n + > + `__bos + ( +__de +/  ( +wch_t +)) + +231  + `__wny_chk_wn + ( +__de +, +__c +, +__n +, + +232 + `__bos + ( +__de +/  ( +wch_t +)); + +234  + `__wny_s + ( +__de +, +__c +, +__n +); + +235 + } +} + +238 +wch_t + * + $__wcst_chk + ( +wch_t + * +__ri + +__de +, + +239 +__cڡ + +wch_t + * +__ri + +__c +, + +240 +size_t + +__den + +__THROW +; + +241 +wch_t + * + `__REDIRECT_NTH + ( +__wcst_s +, + +242 ( +wch_t + * +__ri + +__de +, + +243 +__cڡ + +wch_t + * +__ri + +__c +), +wcst +); + +245 +__ex_ways_le + +wch_t + * + +246 + `__NTH + ( + $wcst + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +)) + +248 i( + `__bos + ( +__de +!( +size_t +) -1) + +249  + `__wcst_chk + ( +__de +, +__c +, + `__bos + (__de/  ( +wch_t +)); + +250  + `__wcst_s + ( +__de +, +__c +); + +251 + } +} + +254 +wch_t + * + $__wct_chk + ( +wch_t + * +__ri + +__de +, + +255 +__cڡ + +wch_t + * +__ri + +__c +, + +256 +size_t + +__n +, size_ +__den + +__THROW +; + +257 +wch_t + * + `__REDIRECT_NTH + ( +__wct_s +, + +258 ( +wch_t + * +__ri + +__de +, + +259 +__cڡ + +wch_t + * +__ri + +__c +, + +260 +size_t + +__n +), +wct +); + +262 +__ex_ways_le + +wch_t + * + +263 + `__NTH + ( + $wct + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +)) + +265 i( + `__bos + ( +__de +!( +size_t +) -1) + +266  + `__wct_chk + ( +__de +, +__c +, +__n +, + +267 + `__bos + ( +__de +/  ( +wch_t +)); + +268  + `__wct_s + ( +__de +, +__c +, +__n +); + +269 + } +} + +272  + $__swtf_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +273  +__ag +, +size_t + +__s_n +, + +274 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +275 +__THROW + ; + +277  + `__REDIRECT_NTH_LDBL + ( +__swtf_s +, + +278 ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +279 +__cڡ + +wch_t + * +__ri + +__fmt +, ...), + +280 +swtf +); + +282 #ifde +__va_g_ck + + +283 +__ex_ways_le +  + +284 + `__NTH + ( + $swtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +285 +__cڡ + +wch_t + * +__ri + +__fmt +, ...)) + +287 i( + `__bos + ( +__s +!( +size_t +-1 || +__USE_FORTIFY_LEVEL + > 1) + +288  + `__swtf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +289 + `__bos + ( +__s +/  ( +wch_t +), + +290 +__fmt +, + `__va_g_ck + ()); + +291  + `__swtf_s + ( +__s +, +__n +, +__fmt +, + `__va_g_ck + ()); + +292 + } +} + +293 #i! +defed + +__lulus + + +295  + #swtf +( +s +, +n +, ...) \ + +296 ( + `__bos + ( +s +!( +size_t +-1 || +__USE_FORTIFY_LEVEL + > 1 \ + +297 ? + `__swtf_chk + ( +s +, +n +, +__USE_FORTIFY_LEVEL + - 1, \ + +298 + `__bos + ( +s +/  ( +wch_t +), +__VA_ARGS__ +) \ + +299 : + `swtf + ( +s +, +n +, +__VA_ARGS__ +)) + + ) + +302  + $__vswtf_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +303  +__ag +, +size_t + +__s_n +, + +304 +__cڡ + +wch_t + * +__ri + +__fm +, + +305 +__gnuc_va_li + +__g +) + +306 +__THROW + ; + +308  + `__REDIRECT_NTH_LDBL + ( +__vswtf_s +, + +309 ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +310 +__cڡ + +wch_t + * +__ri + +__fmt +, + +311 +__gnuc_va_li + +__ +), +vswtf +); + +313 +__ex_ways_le +  + +314 + `__NTH + ( + $vswtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +315 +__cڡ + +wch_t + * +__ri + +__fmt +, +__gnuc_va_li + +__ +)) + +317 i( + `__bos + ( +__s +!( +size_t +-1 || +__USE_FORTIFY_LEVEL + > 1) + +318  + `__vswtf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +319 + `__bos + ( +__s +/  ( +wch_t +), +__fmt +, +__ +); + +320  + `__vswtf_s + ( +__s +, +__n +, +__fmt +, +__ +); + +321 + } +} + +324 #i +__USE_FORTIFY_LEVEL + > 1 + +326  +__fwtf_chk + ( +__FILE + * +__ri + +__am +,  +__ag +, + +327 +__cڡ + +wch_t + * +__ri + +__fm +, ...); + +328  +__wtf_chk + ( +__ag +, +__cڡ + +wch_t + * +__ri + +__fm +, + +330  +__vfwtf_chk + ( +__FILE + * +__ri + +__am +,  +__ag +, + +331 +__cڡ + +wch_t + * +__ri + +__fm +, + +332 +__gnuc_va_li + +__ +); + +333  +__vwtf_chk + ( +__ag +, +__cڡ + +wch_t + * +__ri + +__fm +, + +334 +__gnuc_va_li + +__ +); + +336 #ifde +__va_g_ck + + +337 +__ex_ways_le +  + +338 + $wtf + ( +__cڡ + +wch_t + * +__ri + +__fmt +, ...) + +340  + `__wtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + `__va_g_ck + ()); + +341 + } +} + +343 +__ex_ways_le +  + +344 + $fwtf + ( +__FILE + * +__ri + +__am +, +__cڡ + +wch_t + *__ri +__fmt +, ...) + +346  + `__fwtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +347 + `__va_g_ck + ()); + +348 + } +} + +349 #i! +defed + +__lulus + + +350  + #wtf +(...) \ + +351 + `__wtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +352  + #fwtf +( +am +, ...) \ + +353 + `__fwtf_chk + ( +am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +356 +__ex_ways_le +  + +357 + $vwtf + ( +__cڡ + +wch_t + * +__ri + +__fmt +, +__gnuc_va_li + +__ +) + +359  + `__vwtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +360 + } +} + +362 +__ex_ways_le +  + +363 + $vfwtf + ( +__FILE + * +__ri + +__am +, + +364 +__cڡ + +wch_t + * +__ri + +__fmt +, +__gnuc_va_li + +__ +) + +366  + `__vfwtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +367 + } +} + +371 +wch_t + * + $__fgws_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__size +,  +__n +, + +372 +__FILE + * +__ri + +__am + +__wur +; + +373 +wch_t + * + `__REDIRECT + ( +__fgws_s +, + +374 ( +wch_t + * +__ri + +__s +,  +__n +, + +375 +__FILE + * +__ri + +__am +), +fgws + +__wur +; + +376 +wch_t + * + `__REDIRECT + ( +__fgws_chk_wn +, + +377 ( +wch_t + * +__ri + +__s +, +size_t + +__size +,  +__n +, + +378 +__FILE + * +__ri + +__am +), +__fgws_chk +) + +379 +__wur + + `__wljr + ("fgetws called with bigger sizehanength " + +382 +__ex_ways_le + +__wur + +wch_t + * + +383 + $fgws + ( +wch_t + * +__ri + +__s +,  +__n +, +__FILE + *__ri +__am +) + +385 i( + `__bos + ( +__s +!( +size_t +) -1) + +387 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +388  + `__fgws_chk + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +389 +__n +, +__am +); + +391 i(( +size_t + +__n + > + `__bos + ( +__s +/  ( +wch_t +)) + +392  + `__fgws_chk_wn + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +393 +__n +, +__am +); + +395  + `__fgws_s + ( +__s +, +__n +, +__am +); + +396 + } +} + +398 #ifde +__USE_GNU + + +399 +wch_t + * + $__fgws_uocked_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__size +, + +400  +__n +, +__FILE + * +__ri + +__am +) + +401 +__wur +; + +402 +wch_t + * + `__REDIRECT + ( +__fgws_uocked_s +, + +403 ( +wch_t + * +__ri + +__s +,  +__n +, + +404 +__FILE + * +__ri + +__am +), +fgws_uocked +) + +405 +__wur +; + +406 +wch_t + * + `__REDIRECT + ( +__fgws_uocked_chk_wn +, + +407 ( +wch_t + * +__ri + +__s +, +size_t + +__size +,  +__n +, + +408 +__FILE + * +__ri + +__am +), + +409 +__fgws_uocked_chk +) + +410 +__wur + + `__wljr + ("fgetws_unlocked called with bigger sizehanength " + +413 +__ex_ways_le + +__wur + +wch_t + * + +414 + $fgws_uocked + ( +wch_t + * +__ri + +__s +,  +__n +, +__FILE + *__ri +__am +) + +416 i( + `__bos + ( +__s +!( +size_t +) -1) + +418 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +419  + `__fgws_uocked_chk + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +420 +__n +, +__am +); + +422 i(( +size_t + +__n + > + `__bos + ( +__s +/  ( +wch_t +)) + +423  + `__fgws_uocked_chk_wn + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +424 +__n +, +__am +); + +426  + `__fgws_uocked_s + ( +__s +, +__n +, +__am +); + +427 + } +} + +431 +size_t + + $__wtomb_chk + (* +__s +, +wch_t + +__wch +, +mbe_t + * +__p +, + +432 +size_t + +__bu + +__THROW + +__wur +; + +433 +size_t + + `__REDIRECT_NTH + ( +__wtomb_s +, + +434 (* +__ri + +__s +, +wch_t + +__wch +, + +435 +mbe_t + * +__ri + +__ps +), +wtomb + +__wur +; + +437 +__ex_ways_le + +__wur + +size_t + + +438 + `__NTH + ( + $wtomb + (* +__s +, +wch_t + +__wch +, +mbe_t + * +__ps +)) + +443  + #__WCHAR_MB_LEN_MAX + 16 + + ) + +444 #i +defed + +MB_LEN_MAX + && MB_LEN_MAX ! +__WCHAR_MB_LEN_MAX + + +447 i( + `__bos + ( +__s +!( +size_t +-1 && +__WCHAR_MB_LEN_MAX + > __bos (__s)) + +448  + `__wtomb_chk + ( +__s +, +__wch +, +__ps +, + `__bos + (__s)); + +449  + `__wtomb_s + ( +__s +, +__wch +, +__ps +); + +450 + } +} + +453 +size_t + + $__mbtowcs_chk + ( +wch_t + * +__ri + +__d +, + +454 +__cڡ + ** +__ri + +__c +, + +455 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +456 +size_t + +__dn + +__THROW +; + +457 +size_t + + `__REDIRECT_NTH + ( +__mbtowcs_s +, + +458 ( +wch_t + * +__ri + +__d +, + +459 +__cڡ + ** +__ri + +__c +, + +460 +size_t + +__n +, +mbe_t + * +__ri + +__ps +), + +461 +mbtowcs +); + +462 +size_t + + `__REDIRECT_NTH + ( +__mbtowcs_chk_wn +, + +463 ( +wch_t + * +__ri + +__d +, + +464 +__cڡ + ** +__ri + +__c +, + +465 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +466 +size_t + +__dn +), +__mbtowcs_chk +) + +467 + `__wljr + ("mbsrtowcs called with dst buffer smallerhanen " + +470 +__ex_ways_le + +size_t + + +471 + `__NTH + ( + $mbtowcs + ( +wch_t + * +__ri + +__d +, +__cڡ + **__ri +__c +, + +472 +size_t + +__n +, +mbe_t + * +__ri + +__ps +)) + +474 i( + `__bos + ( +__d +!( +size_t +) -1) + +476 i(! + `__but_cڡt_p + ( +__n +)) + +477  + `__mbtowcs_chk + ( +__d +, +__c +, +__n +, +__ps +, + +478 + `__bos + ( +__d +/  ( +wch_t +)); + +480 i( +__n + > + `__bos + ( +__d +/  ( +wch_t +)) + +481  + `__mbtowcs_chk_wn + ( +__d +, +__c +, +__n +, +__ps +, + +482 + `__bos + ( +__d +/  ( +wch_t +)); + +484  + `__mbtowcs_s + ( +__d +, +__c +, +__n +, +__ps +); + +485 + } +} + +488 +size_t + + $__wctombs_chk + (* +__ri + +__d +, + +489 +__cڡ + +wch_t + ** +__ri + +__c +, + +490 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +491 +size_t + +__dn + +__THROW +; + +492 +size_t + + `__REDIRECT_NTH + ( +__wctombs_s +, + +493 (* +__ri + +__d +, + +494 +__cڡ + +wch_t + ** +__ri + +__c +, + +495 +size_t + +__n +, +mbe_t + * +__ri + +__ps +), + +496 +wctombs +); + +497 +size_t + + `__REDIRECT_NTH + ( +__wctombs_chk_wn +, + +498 (* +__ri + +__d +, + +499 +__cڡ + +wch_t + ** +__ri + +__c +, + +500 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +501 +size_t + +__dn +), +__wctombs_chk +) + +502 + `__wljr + ("wcsrtombs called with dst buffer smallerhanen"); + +504 +__ex_ways_le + +size_t + + +505 + `__NTH + ( + $wctombs + (* +__ri + +__d +, +__cڡ + +wch_t + **__ri +__c +, + +506 +size_t + +__n +, +mbe_t + * +__ri + +__ps +)) + +508 i( + `__bos + ( +__d +!( +size_t +) -1) + +510 i(! + `__but_cڡt_p + ( +__n +)) + +511  + `__wctombs_chk + ( +__d +, +__c +, +__n +, +__ps +, + `__bos + (__dst)); + +513 i( +__n + > + `__bos + ( +__d +)) + +514  + `__wctombs_chk_wn + ( +__d +, +__c +, +__n +, +__ps +, + `__bos + (__dst)); + +516  + `__wctombs_s + ( +__d +, +__c +, +__n +, +__ps +); + +517 + } +} + +520 #ifde +__USE_GNU + + +521 +size_t + + $__mbowcs_chk + ( +wch_t + * +__ri + +__d +, + +522 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +523 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +524 +size_t + +__dn + +__THROW +; + +525 +size_t + + `__REDIRECT_NTH + ( +__mbowcs_s +, + +526 ( +wch_t + * +__ri + +__d +, + +527 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +528 +size_t + +__n +, +mbe_t + * +__ri + +__ps +), + +529 +mbowcs +); + +530 +size_t + + `__REDIRECT_NTH + ( +__mbowcs_chk_wn +, + +531 ( +wch_t + * +__ri + +__d +, + +532 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +533 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +534 +size_t + +__dn +), +__mbowcs_chk +) + +535 + `__wljr + ("mbsnrtowcs called with dst buffer smallerhanen " + +538 +__ex_ways_le + +size_t + + +539 + `__NTH + ( + $mbowcs + ( +wch_t + * +__ri + +__d +, +__cڡ + **__ri +__c +, + +540 +size_t + +__nmc +, size_ +__n +, +mbe_t + * +__ri + +__ps +)) + +542 i( + `__bos + ( +__d +!( +size_t +) -1) + +544 i(! + `__but_cڡt_p + ( +__n +)) + +545  + `__mbowcs_chk + ( +__d +, +__c +, +__nmc +, +__n +, +__ps +, + +546 + `__bos + ( +__d +/  ( +wch_t +)); + +548 i( +__n + > + `__bos + ( +__d +/  ( +wch_t +)) + +549  + `__mbowcs_chk_wn + ( +__d +, +__c +, +__nmc +, +__n +, +__ps +, + +550 + `__bos + ( +__d +/  ( +wch_t +)); + +552  + `__mbowcs_s + ( +__d +, +__c +, +__nmc +, +__n +, +__ps +); + +553 + } +} + +556 +size_t + + $__wcombs_chk + (* +__ri + +__d +, + +557 +__cڡ + +wch_t + ** +__ri + +__c +, + +558 +size_t + +__nwc +, size_ +__n +, + +559 +mbe_t + * +__ri + +__ps +, +size_t + +__dn +) + +560 +__THROW +; + +561 +size_t + + `__REDIRECT_NTH + ( +__wcombs_s +, + +562 (* +__ri + +__d +, + +563 +__cڡ + +wch_t + ** +__ri + +__c +, + +564 +size_t + +__nwc +, size_ +__n +, + +565 +mbe_t + * +__ri + +__ps +), +wcombs +); + +566 +size_t + + `__REDIRECT_NTH + ( +__wcombs_chk_wn +, + +567 (* +__ri + +__d +, + +568 +__cڡ + +wch_t + ** +__ri + +__c +, + +569 +size_t + +__nwc +, size_ +__n +, + +570 +mbe_t + * +__ri + +__ps +, + +571 +size_t + +__dn +), +__wcombs_chk +) + +572 + `__wljr + ("wcsnrtombs called with dst buffer smallerhanen"); + +574 +__ex_ways_le + +size_t + + +575 + `__NTH + ( + $wcombs + (* +__ri + +__d +, +__cڡ + +wch_t + **__ri +__c +, + +576 +size_t + +__nwc +, size_ +__n +, +mbe_t + * +__ri + +__ps +)) + +578 i( + `__bos + ( +__d +!( +size_t +) -1) + +580 i(! + `__but_cڡt_p + ( +__n +)) + +581  + `__wcombs_chk + ( +__d +, +__c +, +__nwc +, +__n +, +__ps +, + +582 + `__bos + ( +__d +)); + +584 i( +__n + > + `__bos + ( +__d +)) + +585  + `__wcombs_chk_wn + ( +__d +, +__c +, +__nwc +, +__n +, +__ps +, + +586 + `__bos + ( +__d +)); + +588  + `__wcombs_s + ( +__d +, +__c +, +__nwc +, +__n +, +__ps +); + +589 + } +} + + @/usr/include/errno.h + +23 #idef +_ERRNO_H + + +27 #idef +__ed_Emh + + +28  + #_ERRNO_H + 1 + + ) + +29  + ~ + +32 + g__BEGIN_DECLS + + +36  + ~ + +37 #unde +__ed_Emh + + +39 #ifdef +_ERRNO_H + + +46 #idef +o + + +47  +o +; + +50 #ifde +__USE_GNU + + +55 * +ogm_voti_me +, * +ogm_voti_sht_me +; + +59 + g__END_DECLS + + +67 #i +defed + +__USE_GNU + || defed +__ed_r_t + + +68 #ide +__r_t_defed + + +69  + tr_t +; + +70  + #__r_t_defed + 1 + + ) + +72 #unde +__ed_r_t + + + @/usr/include/gnu/option-groups.h + +10 #ide +__GNU_OPTION_GROUPS_H + + +11  + #__GNU_OPTION_GROUPS_H + + + ) + +13  + #__OPTION_EGLIBC_ADVANCED_INET6 + 1 + + ) + +14  + #__OPTION_EGLIBC_BACKTRACE + 1 + + ) + +15  + #__OPTION_EGLIBC_BIG_MACROS + 1 + + ) + +16  + #__OPTION_EGLIBC_BSD + 1 + + ) + +17  + #__OPTION_EGLIBC_CATGETS + 1 + + ) + +18  + #__OPTION_EGLIBC_CHARSETS + 1 + + ) + +19  + #__OPTION_EGLIBC_CXX_TESTS + 1 + + ) + +20  + #__OPTION_EGLIBC_DB_ALIASES + 1 + + ) + +21  + #__OPTION_EGLIBC_ENVZ + 1 + + ) + +22  + #__OPTION_EGLIBC_FCVT + 1 + + ) + +23  + #__OPTION_EGLIBC_FMTMSG + 1 + + ) + +24  + #__OPTION_EGLIBC_FSTAB + 1 + + ) + +25  + #__OPTION_EGLIBC_FTRAVERSE + 1 + + ) + +26  + #__OPTION_EGLIBC_GETLOGIN + 1 + + ) + +27  + #__OPTION_EGLIBC_INET + 1 + + ) + +28  + #__OPTION_EGLIBC_LIBM + 1 + + ) + +29  + #__OPTION_EGLIBC_LOCALES + 1 + + ) + +30  + #__OPTION_EGLIBC_LOCALE_CODE + 1 + + ) + +31  + #__OPTION_EGLIBC_MEMUSAGE + 1 + + ) + +32  + #__OPTION_EGLIBC_NIS + 1 + + ) + +33  + #__OPTION_EGLIBC_NSSWITCH + 1 + + ) + +34  + #__OPTION_EGLIBC_RCMD + 1 + + ) + +35  + #__OPTION_EGLIBC_SPAWN + 1 + + ) + +36  + #__OPTION_EGLIBC_STREAMS + 1 + + ) + +37  + #__OPTION_EGLIBC_SUNRPC + 1 + + ) + +38  + #__OPTION_EGLIBC_UTMP + 1 + + ) + +39  + #__OPTION_EGLIBC_UTMPX + 1 + + ) + +40  + #__OPTION_EGLIBC_WORDEXP + 1 + + ) + +41  + #__OPTION_POSIX_C_LANG_WIDE_CHAR + 1 + + ) + +42  + #__OPTION_POSIX_REGEXP + 1 + + ) + +43  + #__OPTION_POSIX_REGEXP_GLIBC + 1 + + ) + +44  + #__OPTION_POSIX_WIDE_CHAR_DEVICE_IO + 1 + + ) + + @/usr/include/pthread.h + +20 #ide +_PTHREAD_H + + +21  + #_PTHREAD_H + 1 + + ) + +23  + ~ + +24  + ~ + +25  + ~ + +26  + ~ + +28  + #__ed_sigt_t + + + ) + +29  + ~ + +30  + ~ + +31  + ~ + +32  + ~ + +38 + mPTHREAD_CREATE_JOINABLE +, + +39  + #PTHREAD_CREATE_JOINABLE + +PTHREAD_CREATE_JOINABLE + + + ) + +40 + mPTHREAD_CREATE_DETACHED + + +41  + #PTHREAD_CREATE_DETACHED + +PTHREAD_CREATE_DETACHED + + + ) + +48 + mPTHREAD_MUTEX_TIMED_NP +, + +49 + mPTHREAD_MUTEX_RECURSIVE_NP +, + +50 + mPTHREAD_MUTEX_ERRORCHECK_NP +, + +51 + mPTHREAD_MUTEX_ADAPTIVE_NP + + +52 #ifde +__USE_UNIX98 + + +54 + mPTHREAD_MUTEX_NORMAL + = +PTHREAD_MUTEX_TIMED_NP +, + +55 + mPTHREAD_MUTEX_RECURSIVE + = +PTHREAD_MUTEX_RECURSIVE_NP +, + +56 + mPTHREAD_MUTEX_ERRORCHECK + = +PTHREAD_MUTEX_ERRORCHECK_NP +, + +57 + mPTHREAD_MUTEX_DEFAULT + = +PTHREAD_MUTEX_NORMAL + + +59 #ifde +__USE_GNU + + +61 , + mPTHREAD_MUTEX_FAST_NP + = +PTHREAD_MUTEX_TIMED_NP + + +66 #ifde +__USE_XOPEN2K + + +70 + mPTHREAD_MUTEX_STALLED +, + +71 + mPTHREAD_MUTEX_STALLED_NP + = +PTHREAD_MUTEX_STALLED +, + +72 + mPTHREAD_MUTEX_ROBUST +, + +73 + mPTHREAD_MUTEX_ROBUST_NP + = +PTHREAD_MUTEX_ROBUST + + +78 #ifde +__USE_UNIX98 + + +82 + mPTHREAD_PRIO_NONE +, + +83 + mPTHREAD_PRIO_INHERIT +, + +84 + mPTHREAD_PRIO_PROTECT + + +90 #i +__WORDSIZE + == 64 + +91  + #PTHREAD_MUTEX_INITIALIZER + \ + +92 { { 0, 0, 0, 0, 0, 0, { 0, 0 } } } + + ) + +93 #ifde +__USE_GNU + + +94  + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +95 { { 0, 0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, 0, { 0, 0 } } } + + ) + +96  + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +97 { { 0, 0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, 0, { 0, 0 } } } + + ) + +98  + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +99 { { 0, 0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, 0, { 0, 0 } } } + + ) + +102  + #PTHREAD_MUTEX_INITIALIZER + \ + +103 { { 0, 0, 0, 0, 0, { 0 } } } + + ) + +104 #ifde +__USE_GNU + + +105  + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +106 { { 0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, 0, { 0 } } } + + ) + +107  + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +108 { { 0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, 0, { 0 } } } + + ) + +109  + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +110 { { 0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, 0, { 0 } } } + + ) + +116 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +119 + mPTHREAD_RWLOCK_PREFER_READER_NP +, + +120 + mPTHREAD_RWLOCK_PREFER_WRITER_NP +, + +121 + mPTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, + +122 + mPTHREAD_RWLOCK_DEFAULT_NP + = +PTHREAD_RWLOCK_PREFER_READER_NP + + +126  + #PTHREAD_RWLOCK_INITIALIZER + \ + +127 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } + + ) + +128 #ifde +__USE_GNU + + +129 #i +__WORDSIZE + == 64 + +130  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +132 +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP + } } + + ) + +134 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +135  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +136 { { 0, 0, 0, 0, 0, 0, +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, \ + +137 0, 0, 0, 0 } } + + ) + +139  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +140 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +,\ + +141 0 } } + + ) + +151 + mPTHREAD_INHERIT_SCHED +, + +152  + #PTHREAD_INHERIT_SCHED + +PTHREAD_INHERIT_SCHED + + + ) + +153 + mPTHREAD_EXPLICIT_SCHED + + +154  + #PTHREAD_EXPLICIT_SCHED + +PTHREAD_EXPLICIT_SCHED + + + ) + +161 + mPTHREAD_SCOPE_SYSTEM +, + +162  + #PTHREAD_SCOPE_SYSTEM + +PTHREAD_SCOPE_SYSTEM + + + ) + +163 + mPTHREAD_SCOPE_PROCESS + + +164  + #PTHREAD_SCOPE_PROCESS + +PTHREAD_SCOPE_PROCESS + + + ) + +171 + mPTHREAD_PROCESS_PRIVATE +, + +172  + #PTHREAD_PROCESS_PRIVATE + +PTHREAD_PROCESS_PRIVATE + + + ) + +173 + mPTHREAD_PROCESS_SHARED + + +174  + #PTHREAD_PROCESS_SHARED + +PTHREAD_PROCESS_SHARED + + + ) + +180  + #PTHREAD_COND_INITIALIZER + { { 0, 0, 0, 0, 0, (*0, 0, 0 } } + + ) + +184  + s_had_nup_bufr + + +186 (* + m__route +) (*); + +187 * + m__g +; + +188  + m__ny +; + +189  +_had_nup_bufr + * + m__ev +; + +195 + mPTHREAD_CANCEL_ENABLE +, + +196  + #PTHREAD_CANCEL_ENABLE + +PTHREAD_CANCEL_ENABLE + + + ) + +197 + mPTHREAD_CANCEL_DISABLE + + +198  + #PTHREAD_CANCEL_DISABLE + +PTHREAD_CANCEL_DISABLE + + + ) + +202 + mPTHREAD_CANCEL_DEFERRED +, + +203  + #PTHREAD_CANCEL_DEFERRED + +PTHREAD_CANCEL_DEFERRED + + + ) + +204 + mPTHREAD_CANCEL_ASYNCHRONOUS + + +205  + #PTHREAD_CANCEL_ASYNCHRONOUS + +PTHREAD_CANCEL_ASYNCHRONOUS + + + ) + +207  + #PTHREAD_CANCELED + ((*-1) + + ) + +211  + #PTHREAD_ONCE_INIT + 0 + + ) + +214 #ifde +__USE_XOPEN2K + + +218  + #PTHREAD_BARRIER_SERIAL_THREAD + -1 + + ) + +222 +__BEGIN_DECLS + + +227  +had_ + ( +had_t + * +__ri + +__wthad +, + +228 +__cڡ + +had__t + * +__ri + +__ +, + +229 *(* +__t_route +) (*), + +230 * +__ri + +__g + +__THROW + +__nnu + ((1, 3)); + +236  + $had_ex + (* +__tv + + `__ibu__ + (( +__nܑu__ +)); + +244  + `had_jo + ( +had_t + +__th +, ** +__thad_tu +); + +246 #ifde +__USE_GNU + + +249  + $had_yjo_ + ( +had_t + +__th +, ** +__thad_tu + +__THROW +; + +257  + `had_timedjo_ + ( +had_t + +__th +, ** +__thad_tu +, + +258 +__cڡ +  +timeec + * +__abime +); + +265  + $had_dach + ( +had_t + +__th + +__THROW +; + +269 +had_t + + $had_lf + ( +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +272  + $had_equ + ( +had_t + +__thad1 +,thad_ +__thad2 + +__THROW +; + +280  + $had__ + ( +had__t + * +__ + +__THROW + + `__nnu + ((1)); + +283  + $had__deroy + ( +had__t + * +__ +) + +284 +__THROW + + `__nnu + ((1)); + +287  + $had__gdache + ( +__cڡ + +had__t + * +__ +, + +288 * +__dache +) + +289 +__THROW + + `__nnu + ((1, 2)); + +292  + $had__tdache + ( +had__t + * +__ +, + +293  +__dache +) + +294 +__THROW + + `__nnu + ((1)); + +298  + $had__ggudsize + ( +__cڡ + +had__t + * +__ +, + +299 +size_t + * +__gudsize +) + +300 +__THROW + + `__nnu + ((1, 2)); + +303  + $had__tgudsize + ( +had__t + * +__ +, + +304 +size_t + +__gudsize +) + +305 +__THROW + + `__nnu + ((1)); + +309  + $had__gschedm + ( +__cڡ + +had__t + * +__ri + + +310 +__ +, + +311  +sched_m + * +__ri + +__m +) + +312 +__THROW + + `__nnu + ((1, 2)); + +315  + $had__tschedm + ( +had__t + * +__ri + +__ +, + +316 +__cڡ +  +sched_m + * +__ri + + +317 +__m + +__THROW + + `__nnu + ((1, 2)); + +320  + $had__gschedpicy + ( +__cڡ + +had__t + * +__ri + + +321 +__ +, * +__ri + +__picy +) + +322 +__THROW + + `__nnu + ((1, 2)); + +325  + $had__tschedpicy + ( +had__t + * +__ +,  +__picy +) + +326 +__THROW + + `__nnu + ((1)); + +329  + $had__ghsched + ( +__cڡ + +had__t + * +__ri + + +330 +__ +, * +__ri + +__h +) + +331 +__THROW + + `__nnu + ((1, 2)); + +334  + $had__thsched + ( +had__t + * +__ +, + +335  +__h +) + +336 +__THROW + + `__nnu + ((1)); + +340  + $had__gsce + ( +__cڡ + +had__t + * +__ri + +__ +, + +341 * +__ri + +__sce +) + +342 +__THROW + + `__nnu + ((1, 2)); + +345  + $had__tsce + ( +had__t + * +__ +,  +__sce +) + +346 +__THROW + + `__nnu + ((1)); + +349  + $had__gackaddr + ( +__cڡ + +had__t + * +__ri + + +350 +__ +, ** +__ri + +__ackaddr +) + +351 +__THROW + + `__nnu + ((1, 2) +__ibu_dd__ +; + +357  + $had__tackaddr + ( +had__t + * +__ +, + +358 * +__ackaddr +) + +359 +__THROW + + `__nnu + ((1) +__ibu_dd__ +; + +362  + $had__gacksize + ( +__cڡ + +had__t + * +__ri + + +363 +__ +, +size_t + * +__ri + +__acksize +) + +364 +__THROW + + `__nnu + ((1, 2)); + +369  + $had__tacksize + ( +had__t + * +__ +, + +370 +size_t + +__acksize +) + +371 +__THROW + + `__nnu + ((1)); + +373 #ifde +__USE_XOPEN2K + + +375  + $had__gack + ( +__cڡ + +had__t + * +__ri + +__ +, + +376 ** +__ri + +__ackaddr +, + +377 +size_t + * +__ri + +__acksize +) + +378 +__THROW + + `__nnu + ((1, 2, 3)); + +383  + $had__tack + ( +had__t + * +__ +, * +__ackaddr +, + +384 +size_t + +__acksize + +__THROW + + `__nnu + ((1)); + +387 #ifde +__USE_GNU + + +390  + $had__ffy_ + ( +had__t + * +__ +, + +391 +size_t + +__utsize +, + +392 +__cڡ + +u_t_t + * +__ut +) + +393 +__THROW + + `__nnu + ((1, 3)); + +397  + $had__gaffy_ + ( +__cڡ + +had__t + * +__ +, + +398 +size_t + +__utsize +, + +399 +u_t_t + * +__ut +) + +400 +__THROW + + `__nnu + ((1, 3)); + +406  + $had_g_ + ( +had_t + +__th +, +had__t + * +__ +) + +407 +__THROW + + `__nnu + ((2)); + +415  + $had_tschedm + ( +had_t + +__rg_thad +,  +__picy +, + +416 +__cڡ +  +sched_m + * +__m +) + +417 +__THROW + + `__nnu + ((3)); + +420  + $had_gschedm + ( +had_t + +__rg_thad +, + +421 * +__ri + +__picy +, + +422  +sched_m + * +__ri + +__m +) + +423 +__THROW + + `__nnu + ((2, 3)); + +426  + $had_tschedio + ( +had_t + +__rg_thad +,  +__io +) + +427 +__THROW +; + +430 #ifde +__USE_UNIX98 + + +432  + $had_gccucy + ( +__THROW +; + +435  + $had_tccucy + ( +__v + +__THROW +; + +438 #ifde +__USE_GNU + + +443  + $had_yld + ( +__THROW +; + +448  + $had_ffy_ + ( +had_t + +__th +, +size_t + +__utsize +, + +449 +__cڡ + +u_t_t + * +__ut +) + +450 +__THROW + + `__nnu + ((3)); + +453  + $had_gaffy_ + ( +had_t + +__th +, +size_t + +__utsize +, + +454 +u_t_t + * +__ut +) + +455 +__THROW + + `__nnu + ((3)); + +468  + `had_ + ( +had__t + * +___cڌ +, + +469 (* +___route +() + `__nnu + ((1, 2)); + +480  + `had_tnle + ( +__e +, * +__de +); + +484  + `had_tny + ( +__ty +, * +__dty +); + +487  + `had_nl + ( +had_t + +__th +); + +492  + `had_nl + (); + +501 +__jmp_buf + +__nl_jmp_buf +; + +502  +__mask_was_ved +; + +503 } +__nl_jmp_buf +[1]; + +504 * +__d +[4]; + +505 } + t__had_unwd_buf_t + + t__ibu__ + (( + t__igd__ +)); + +508 #ide +__nup_f_ibu + + +509  + #__nup_f_ibu + + + ) + +514  + s__had_nup_ame + + +516 (* +__nl_route +) (*); + +517 * +__nl_g +; + +518  +__do_ +; + +519  +__nl_ty +; + +522 #i +defed + +__GNUC__ + && defed +__EXCEPTIONS + + +523 #ifde +__lulus + + +525 as + c__had_nup_ass + + +527 (* +__nl_route +) (*); + +528 * +__nl_g +; + +529  +__do_ +; + +530  +__nl_ty +; + +532 +public +: + +533 + `__had_nup_ass + ((* +__f +(*), * +__g +) + +534 : + `__nl_route + ( +__f +), + `__nl_g + ( +__g +), + $__do_ + (1) { } + +535 ~ + $__had_nup_ass + ({ i( +__do_ + + `__nl_route + ( +__nl_g +); + } +} + +536  + $__tdo + ( +__wv +{ +__do_ + = __wv; + } +} + +537  + $__der + ({ + `had_tny + ( +PTHREAD_CANCEL_DEFERRED +, + +538 & +__nl_ty +); + } +} + +539  + $__e + (cڡ { + `had_tny + ( +__nl_ty +, 0); + } +} + +549  + #had_nup_push +( +route +, +g +) \ + +551 +__had_nup_ass + + `__ame + ( +route +, +g +) + + ) + +555  + #had_nup_p +( +execu +) \ + +556 +__ame +. + `__tdo + ( +execu +); \ + +557 } 0) + + ) + +559 #ifde +__USE_GNU + + +563  + #had_nup_push_der_ +( +route +, +g +) \ + +565 +__had_nup_ass + + `__ame + ( +route +, +g +); \ + +566 +__ame +. + `__der + () + + ) + +571  + #had_nup_p_e_ +( +execu +) \ + +572 +__ame +. + `__e + (); \ + +573 +__ame +. + `__tdo + ( +execu +); \ + +574 } 0) + + ) + +581 +__ex_le +  + +582 + $__had_nup_route + ( +__had_nup_ame + * +__ame +) + +584 i( +__ame +-> +__do_ +) + +585 +__ame +-> + `__nl_route + (__ame-> +__nl_g +); + +586 + } +} + +595  + #had_nup_push +( +route +, +g +) \ + +597  +__had_nup_ame + +__ame + \ + +598 + `__ibu__ + (( + `__nup__ + ( +__had_nup_route +))) \ + +599 { . +__nl_route + = ( +route +), . +__nl_g + = ( +g +), \ + +600 . +__do_ + = 1 }; + + ) + +604  + #had_nup_p +( +execu +) \ + +605 +__ame +. +__do_ + = ( +execu +); \ + +606 } 0) + + ) + +608 #ifde +__USE_GNU + + +612  + #had_nup_push_der_ +( +route +, +g +) \ + +614  +__had_nup_ame + +__ame + \ + +615 + `__ibu__ + (( + `__nup__ + ( +__had_nup_route +))) \ + +616 { . +__nl_route + = ( +route +), . +__nl_g + = ( +g +), \ + +617 . +__do_ + = 1 }; \ + +618 ( + `had_tny + ( +PTHREAD_CANCEL_DEFERRED +, \ + +619 & +__ame +. +__nl_ty +) + + ) + +624  + #had_nup_p_e_ +( +execu +) \ + +625 ( + `had_tny + ( +__ame +. +__nl_ty +, +NULL +); \ + +626 +__ame +. +__do_ + = ( +execu +); \ + +627 } 0) + + ) + +638  + #had_nup_push +( +route +, +g +) \ + +640 +__had_unwd_buf_t + +__nl_buf +; \ + +641 (* +__nl_route +(*( +route +); \ + +642 * +__nl_g + = ( +g +); \ + +643  +n_f_ + = + `__sigtjmp + (( +__jmp_buf_g + *) (*) \ + +644 +__nl_buf +. +__nl_jmp_buf +, 0); \ + +645 i( + `__but_ex + ( +n_f_ +, 0)) \ + +647 + `__nl_route + ( +__nl_g +); \ + +648 + `__had_unwd_xt + (& +__nl_buf +); \ + +652 + `__had_gi_nl + (& +__nl_buf +); \ + +653 d{ + + ) + +654  +__had_gi_nl + ( +__had_unwd_buf_t + * +__buf +) + +655 +__nup_f_ibu +; + +659  + #had_nup_p +( +execu +) \ + +662 + `__had_uegi_nl + (& +__nl_buf +); \ + +663 i( +execu +) \ + +664 + `__nl_route + ( +__nl_g +); \ + +665 } 0) + + ) + +666  + $__had_uegi_nl + ( +__had_unwd_buf_t + * +__buf +) + +667 +__nup_f_ibu +; + +669 #ifde +__USE_GNU + + +673  + #had_nup_push_der_ +( +route +, +g +) \ + +675 +__had_unwd_buf_t + +__nl_buf +; \ + +676 (* +__nl_route +(*( +route +); \ + +677 * +__nl_g + = ( +g +); \ + +678  +n_f_ + = + `__sigtjmp + (( +__jmp_buf_g + *) (*) \ + +679 +__nl_buf +. +__nl_jmp_buf +, 0); \ + +680 i( + `__but_ex + ( +n_f_ +, 0)) \ + +682 + `__nl_route + ( +__nl_g +); \ + +683 + `__had_unwd_xt + (& +__nl_buf +); \ + +687 + `__had_gi_nl_der + (& +__nl_buf +); \ + +688 d{ + + ) + +689  + `__had_gi_nl_der + ( +__had_unwd_buf_t + * +__buf +) + +690 +__nup_f_ibu +; + +695  + #had_nup_p_e_ +( +execu +) \ + +698 + `__had_uegi_nl_e + (& +__nl_buf +); \ + +699 i( +execu +) \ + +700 + `__nl_route + ( +__nl_g +); \ + +701 + } +} 0) + + ) + +702  + $__had_uegi_nl_e + ( +__had_unwd_buf_t + * +__buf +) + +703 +__nup_f_ibu +; + +707  + $__had_unwd_xt + ( +__had_unwd_buf_t + * +__buf +) + +708 +__nup_f_ibu + + `__ibu__ + (( +__nܑu__ +)) + +709 #ide +SHARED + + +710 + `__ibu__ + (( +__wk__ +)) + +716  +__jmp_buf_g +; + +717  + $__sigtjmp + ( +__jmp_buf_g + * +__v +,  +__vemask + +__THROW +; + +723  + $had_mux_ + ( +had_mux_t + * +__mux +, + +724 +__cڡ + +had_mux_t + * +__mux +) + +725 +__THROW + + `__nnu + ((1)); + +728  + $had_mux_deroy + ( +had_mux_t + * +__mux +) + +729 +__THROW + + `__nnu + ((1)); + +732  + $had_mux_ylock + ( +had_mux_t + * +__mux +) + +733 +__THROW + + `__nnu + ((1)); + +736  + $had_mux_lock + ( +had_mux_t + * +__mux +) + +737 +__THROW + + `__nnu + ((1)); + +739 #ifde +__USE_XOPEN2K + + +741  + $had_mux_timedlock + ( +had_mux_t + * +__ri + +__mux +, + +742 +__cڡ +  +timeec + * +__ri + + +743 +__abime + +__THROW + + `__nnu + ((1, 2)); + +747  + $had_mux_uock + ( +had_mux_t + * +__mux +) + +748 +__THROW + + `__nnu + ((1)); + +751 #ifde +__USE_UNIX98 + + +753  + $had_mux_giog + ( +__cڡ + +had_mux_t + * + +754 +__ri + +__mux +, + +755 * +__ri + +__iog +) + +756 +__THROW + + `__nnu + ((1, 2)); + +760  + $had_mux_riog + ( +had_mux_t + * +__ri + +__mux +, + +761  +__iog +, + +762 * +__ri + +__d_g +) + +763 +__THROW + + `__nnu + ((1, 3)); + +767 #ifde +__USE_XOPEN2K8 + + +769  + $had_mux_csit_ + ( +had_mux_t + * +__mux +) + +770 +__THROW + + `__nnu + ((1)); + +771 #ifde +__USE_GNU + + +772  + $had_mux_csit_ + ( +had_mux_t + * +__mux +) + +773 +__THROW + + `__nnu + ((1)); + +782  + $had_mux_ + ( +had_mux_t + * +__ +) + +783 +__THROW + + `__nnu + ((1)); + +786  + $had_mux_deroy + ( +had_mux_t + * +__ +) + +787 +__THROW + + `__nnu + ((1)); + +790  + $had_mux_gpshed + ( +__cڡ + +had_mux_t + * + +791 +__ri + +__ +, + +792 * +__ri + +__pshed +) + +793 +__THROW + + `__nnu + ((1, 2)); + +796  + $had_mux_shed + ( +had_mux_t + * +__ +, + +797  +__pshed +) + +798 +__THROW + + `__nnu + ((1)); + +800 #ifde +__USE_UNIX98 + + +802  + $had_mux_gty + ( +__cڡ + +had_mux_t + * +__ri + + +803 +__ +, * +__ri + +__kd +) + +804 +__THROW + + `__nnu + ((1, 2)); + +809  + $had_mux_y + ( +had_mux_t + * +__ +,  +__kd +) + +810 +__THROW + + `__nnu + ((1)); + +813  + $had_mux_goc + ( +__cڡ + +had_mux_t + * + +814 +__ri + +__ +, + +815 * +__ri + +__oc +) + +816 +__THROW + + `__nnu + ((1, 2)); + +820  + $had_mux_roc + ( +had_mux_t + * +__ +, + +821  +__oc +) + +822 +__THROW + + `__nnu + ((1)); + +825  + $had_mux_giog + ( +__cڡ + +had_mux_t + * + +826 +__ri + +__ +, + +827 * +__ri + +__iog +) + +828 +__THROW + + `__nnu + ((1, 2)); + +831  + $had_mux_riog + ( +had_mux_t + * +__ +, + +832  +__iog +) + +833 +__THROW + + `__nnu + ((1)); + +836 #ifde +__USE_XOPEN2K + + +838  + $had_mux_grobu + ( +__cڡ + +had_mux_t + * +__ +, + +839 * +__robuss +) + +840 +__THROW + + `__nnu + ((1, 2)); + +841 #ifde +__USE_GNU + + +842  + $had_mux_grobu_ + ( +__cڡ + +had_mux_t + * +__ +, + +843 * +__robuss +) + +844 +__THROW + + `__nnu + ((1, 2)); + +848  + $had_mux_obu + ( +had_mux_t + * +__ +, + +849  +__robuss +) + +850 +__THROW + + `__nnu + ((1)); + +851 #ifde +__USE_GNU + + +852  + $had_mux_obu_ + ( +had_mux_t + * +__ +, + +853  +__robuss +) + +854 +__THROW + + `__nnu + ((1)); + +859 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +864  + $had_rwlock_ + ( +had_rwlock_t + * +__ri + +__rwlock +, + +865 +__cڡ + +had_rwlock_t + * +__ri + + +866 +__ + +__THROW + + `__nnu + ((1)); + +869  + $had_rwlock_deroy + ( +had_rwlock_t + * +__rwlock +) + +870 +__THROW + + `__nnu + ((1)); + +873  + $had_rwlock_rdlock + ( +had_rwlock_t + * +__rwlock +) + +874 +__THROW + + `__nnu + ((1)); + +877  + $had_rwlock_yrdlock + ( +had_rwlock_t + * +__rwlock +) + +878 +__THROW + + `__nnu + ((1)); + +880 #ifde +__USE_XOPEN2K + + +882  + $had_rwlock_timedrdlock + ( +had_rwlock_t + * +__ri + +__rwlock +, + +883 +__cڡ +  +timeec + * +__ri + + +884 +__abime + +__THROW + + `__nnu + ((1, 2)); + +888  + $had_rwlock_wock + ( +had_rwlock_t + * +__rwlock +) + +889 +__THROW + + `__nnu + ((1)); + +892  + $had_rwlock_ywock + ( +had_rwlock_t + * +__rwlock +) + +893 +__THROW + + `__nnu + ((1)); + +895 #ifde +__USE_XOPEN2K + + +897  + $had_rwlock_timedwock + ( +had_rwlock_t + * +__ri + +__rwlock +, + +898 +__cڡ +  +timeec + * +__ri + + +899 +__abime + +__THROW + + `__nnu + ((1, 2)); + +903  + $had_rwlock_uock + ( +had_rwlock_t + * +__rwlock +) + +904 +__THROW + + `__nnu + ((1)); + +910  + $had_rwlock_ + ( +had_rwlock_t + * +__ +) + +911 +__THROW + + `__nnu + ((1)); + +914  + $had_rwlock_deroy + ( +had_rwlock_t + * +__ +) + +915 +__THROW + + `__nnu + ((1)); + +918  + $had_rwlock_gpshed + ( +__cڡ + +had_rwlock_t + * + +919 +__ri + +__ +, + +920 * +__ri + +__pshed +) + +921 +__THROW + + `__nnu + ((1, 2)); + +924  + $had_rwlock_shed + ( +had_rwlock_t + * +__ +, + +925  +__pshed +) + +926 +__THROW + + `__nnu + ((1)); + +929  + $had_rwlock_gkd_ + ( +__cڡ + +had_rwlock_t + * + +930 +__ri + +__ +, + +931 * +__ri + +__ef +) + +932 +__THROW + + `__nnu + ((1, 2)); + +935  + $had_rwlock_tkd_ + ( +had_rwlock_t + * +__ +, + +936  +__ef + +__THROW + + `__nnu + ((1)); + +944  + $had_cd_ + ( +had_cd_t + * +__ri + +__cd +, + +945 +__cڡ + +had_cd_t + * +__ri + + +946 +__cd_ + +__THROW + + `__nnu + ((1)); + +949  + $had_cd_deroy + ( +had_cd_t + * +__cd +) + +950 +__THROW + + `__nnu + ((1)); + +953  + $had_cd_sigl + ( +had_cd_t + * +__cd +) + +954 +__THROW + + `__nnu + ((1)); + +957  + $had_cd_brd + ( +had_cd_t + * +__cd +) + +958 +__THROW + + `__nnu + ((1)); + +965  + $had_cd_wa + ( +had_cd_t + * +__ri + +__cd +, + +966 +had_mux_t + * +__ri + +__mux +) + +967 + `__nnu + ((1, 2)); + +976  + $had_cd_timedwa + ( +had_cd_t + * +__ri + +__cd +, + +977 +had_mux_t + * +__ri + +__mux +, + +978 +__cڡ +  +timeec + * +__ri + + +979 +__abime + + `__nnu + ((1, 2, 3)); + +984  + $had_cd_ + ( +had_cd_t + * +__ +) + +985 +__THROW + + `__nnu + ((1)); + +988  + $had_cd_deroy + ( +had_cd_t + * +__ +) + +989 +__THROW + + `__nnu + ((1)); + +992  + $had_cd_gpshed + ( +__cڡ + +had_cd_t + * + +993 +__ri + +__ +, + +994 * +__ri + +__pshed +) + +995 +__THROW + + `__nnu + ((1, 2)); + +998  + $had_cd_shed + ( +had_cd_t + * +__ +, + +999  +__pshed + +__THROW + + `__nnu + ((1)); + +1001 #ifde +__USE_XOPEN2K + + +1003  + $had_cd_gock + ( +__cڡ + +had_cd_t + * + +1004 +__ri + +__ +, + +1005 +__ockid_t + * +__ri + +__ock_id +) + +1006 +__THROW + + `__nnu + ((1, 2)); + +1009  + $had_cd_tock + ( +had_cd_t + * +__ +, + +1010 +__ockid_t + +__ock_id +) + +1011 +__THROW + + `__nnu + ((1)); + +1015 #ifde +__USE_XOPEN2K + + +1020  + $had__ + ( +had_lock_t + * +__lock +,  +__pshed +) + +1021 +__THROW + + `__nnu + ((1)); + +1024  + $had__deroy + ( +had_lock_t + * +__lock +) + +1025 +__THROW + + `__nnu + ((1)); + +1028  + $had__lock + ( +had_lock_t + * +__lock +) + +1029 +__THROW + + `__nnu + ((1)); + +1032  + $had__ylock + ( +had_lock_t + * +__lock +) + +1033 +__THROW + + `__nnu + ((1)); + +1036  + $had__uock + ( +had_lock_t + * +__lock +) + +1037 +__THROW + + `__nnu + ((1)); + +1044  + $had_brr_ + ( +had_brr_t + * +__ri + +__brr +, + +1045 +__cڡ + +had_brr_t + * +__ri + + +1046 +__ +,  +__cou +) + +1047 +__THROW + + `__nnu + ((1)); + +1050  + $had_brr_deroy + ( +had_brr_t + * +__brr +) + +1051 +__THROW + + `__nnu + ((1)); + +1054  + $had_brr_wa + ( +had_brr_t + * +__brr +) + +1055 +__THROW + + `__nnu + ((1)); + +1059  + $had_brr_ + ( +had_brr_t + * +__ +) + +1060 +__THROW + + `__nnu + ((1)); + +1063  + $had_brr_deroy + ( +had_brr_t + * +__ +) + +1064 +__THROW + + `__nnu + ((1)); + +1067  + $had_brr_gpshed + ( +__cڡ + +had_brr_t + * + +1068 +__ri + +__ +, + +1069 * +__ri + +__pshed +) + +1070 +__THROW + + `__nnu + ((1, 2)); + +1073  + $had_brr_shed + ( +had_brr_t + * +__ +, + +1074  +__pshed +) + +1075 +__THROW + + `__nnu + ((1)); + +1087  + `had_key_ + ( +had_key_t + * +__key +, + +1088 (* +__der_funi +) (*)) + +1089 +__THROW + + `__nnu + ((1)); + +1092  + $had_key_de + ( +had_key_t + +__key + +__THROW +; + +1095 * + $had_gecific + ( +had_key_t + +__key + +__THROW +; + +1098  + $had_tecific + ( +had_key_t + +__key +, + +1099 +__cڡ + * +__por + +__THROW + ; + +1102 #ifde +__USE_XOPEN2K + + +1104  + $had_guockid + ( +had_t + +__thad_id +, + +1105 +__ockid_t + * +__ock_id +) + +1106 +__THROW + + `__nnu + ((2)); + +1121  + `had_fk + ((* +__e +) (), + +1122 (* +__ +) (), + +1123 (* +__chd +() +__THROW +; + +1126 #ifde +__USE_EXTERN_INLINES + + +1128 +__ex_le +  + +1129 + `__NTH + ( + $had_equ + ( +had_t + +__thad1 +,thad_ +__thad2 +)) + +1131  +__thad1 + = +__thad2 +; + +1132 + } +} + +1135 + g__END_DECLS + + + @/usr/include/wctype.h + +24 #ide +_WCTYPE_H + + +26  + ~ + +27  + ~ + +29 #ide +__ed_iswxxx + + +30  + #_WCTYPE_H + 1 + + ) + +33  + #__ed_wt_t + + + ) + +34  + ~ + +38 #ide +WEOF + + +39  + #WEOF + (0xffffffffu) + + ) + +42 #unde +__ed_iswxxx + + +47 #ide +__iswxxx_defed + + +48  + #__iswxxx_defed + 1 + + ) + +50 +__BEGIN_NAMESPACE_C99 + + +53  + twy_t +; + +54 + g__END_NAMESPACE_C99 + + +56 #ide +_ISwb + + +61  + ~ + +62 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +63  + #_ISwb +( +b +(1 << (b)) + + ) + +65  + #_ISwb +( +b +) \ + +66 (( +b +) < 8 ? () ((1UL << (bit)) << 24) \ + +67 : (( +b +) < 16 ? () ((1UL << (bit)) << 8) \ + +68 : (( +b +) < 24 ? () ((1UL << (bit)) >> 8) \ + +69 : (((1UL << ( +b +)>> 24)))) + + ) + +74 + m__ISwu + = 0, + +75 + m__ISwlow + = 1, + +76 + m__ISwpha + = 2, + +77 + m__ISwdig + = 3, + +78 + m__ISwxdig + = 4, + +79 + m__ISwa + = 5, + +80 + m__ISwt + = 6, + +81 + m__ISwgph + = 7, + +82 + m__ISwbnk + = 8, + +83 + m__ISwl + = 9, + +84 + m__ISwpun + = 10, + +85 + m__ISwnum + = 11, + +87 + m_ISwu + = +_ISwb + ( +__ISwu +), + +88 + m_ISwlow + = +_ISwb + ( +__ISwlow +), + +89 + m_ISwpha + = +_ISwb + ( +__ISwpha +), + +90 + m_ISwdig + = +_ISwb + ( +__ISwdig +), + +91 + m_ISwxdig + = +_ISwb + ( +__ISwxdig +), + +92 + m_ISwa + = +_ISwb + ( +__ISwa +), + +93 + m_ISwt + = +_ISwb + ( +__ISwt +), + +94 + m_ISwgph + = +_ISwb + ( +__ISwgph +), + +95 + m_ISwbnk + = +_ISwb + ( +__ISwbnk +), + +96 + m_ISwl + = +_ISwb + ( +__ISwl +), + +97 + m_ISwpun + = +_ISwb + ( +__ISwpun +), + +98 + m_ISwnum + = +_ISwb + ( +__ISwnum +) + +103 +__BEGIN_DECLS + + +105 +__BEGIN_NAMESPACE_C99 + + +112  + $iswnum + ( +wt_t + +__wc + +__THROW +; + +118  + $iswpha + ( +wt_t + +__wc + +__THROW +; + +121  + $iswl + ( +wt_t + +__wc + +__THROW +; + +125  + $iswdig + ( +wt_t + +__wc + +__THROW +; + +129  + $iswgph + ( +wt_t + +__wc + +__THROW +; + +134  + $iswlow + ( +wt_t + +__wc + +__THROW +; + +137  + $iswt + ( +wt_t + +__wc + +__THROW +; + +142  + $iswpun + ( +wt_t + +__wc + +__THROW +; + +147  + $iswa + ( +wt_t + +__wc + +__THROW +; + +152  + $iswu + ( +wt_t + +__wc + +__THROW +; + +157  + $iswxdig + ( +wt_t + +__wc + +__THROW +; + +162 #ifde +__USE_ISOC99 + + +163  + $iswbnk + ( +wt_t + +__wc + +__THROW +; + +172 +wy_t + + $wy + ( +__cڡ + * +__ݔty + +__THROW +; + +176  + $iswy + ( +wt_t + +__wc +, +wy_t + +__desc + +__THROW +; + +177 +__END_NAMESPACE_C99 + + +184 +__BEGIN_NAMESPACE_C99 + + +187  +__cڡ + + t__t32_t + * + twns_t +; + +188 +__END_NAMESPACE_C99 + + +189 #ifde +__USE_GNU + + +190 + $__USING_NAMESPACE_C99 +( +wns_t +) + +193 +__BEGIN_NAMESPACE_C99 + + +195 +wt_t + + $towlow + ( +wt_t + +__wc + +__THROW +; + +198 +wt_t + + $towu + ( +wt_t + +__wc + +__THROW +; + +199 +__END_NAMESPACE_C99 + + +201 +__END_DECLS + + +208 #ifde +_WCTYPE_H + + +214 +__BEGIN_DECLS + + +216 +__BEGIN_NAMESPACE_C99 + + +219 +wns_t + + $wns + ( +__cڡ + * +__ݔty + +__THROW +; + +222 +wt_t + + $towns + ( +wt_t + +__wc +, +wns_t + +__desc + +__THROW +; + +223 +__END_NAMESPACE_C99 + + +225 #ifde +__USE_XOPEN2K8 + + +227  + ~ + +231  + $iswnum_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +237  + $iswpha_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +240  + $iswl_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +244  + $iswdig_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +248  + $iswgph_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +253  + $iswlow_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +256  + $iswt_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +261  + $iswpun_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +266  + $iswa_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +271  + $iswu_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +276  + $iswxdig_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +281  + $iswbnk_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +285 +wy_t + + $wy_l + ( +__cڡ + * +__ݔty +, +__lo_t + +__lo +) + +286 +__THROW +; + +290  + $iswy_l + ( +wt_t + +__wc +, +wy_t + +__desc +, +__lo_t + +__lo +) + +291 +__THROW +; + +299 +wt_t + + $towlow_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +302 +wt_t + + $towu_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +306 +wns_t + + $wns_l + ( +__cڡ + * +__ݔty +, +__lo_t + +__lo +) + +307 +__THROW +; + +310 +wt_t + + $towns_l + ( +wt_t + +__wc +, +wns_t + +__desc +, + +311 +__lo_t + +__lo + +__THROW +; + +315 +__END_DECLS + + + @/usr/include/bits/errno.h + +20 #ifde +_ERRNO_H + + +22 #unde +EDOM + + +23 #unde +EILSEQ + + +24 #unde +ERANGE + + +25  + ~ + +28  + #ENOTSUP + +EOPNOTSUPP + + + ) + +31 #ide +ECANCELED + + +32  + #ECANCELED + 125 + + ) + +36 #ide +EOWNERDEAD + + +37  + #EOWNERDEAD + 130 + + ) + +38  + #ENOTRECOVERABLE + 131 + + ) + +41 #ide +__ASSEMBLER__ + + +43 * + $__o_loti + ( +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +45 #i! +defed + +_LIBC + || defed +_LIBC_REENTRANT + + +47  + #o + (* + `__o_loti + ()) + + ) + +52 #i! +defed + +_ERRNO_H + && defed +__ed_Emh + + +56  + #EDOM + 33 + + ) + +57  + #EILSEQ + 84 + + ) + +58  + #ERANGE + 34 + + ) + + @/usr/include/bits/pthreadtypes.h + +20 #ide +_BITS_PTHREADTYPES_H + + +21  + #_BITS_PTHREADTYPES_H + 1 + + ) + +23  + ~ + +25 #i +__WORDSIZE + == 64 + +26  + #__SIZEOF_PTHREAD_ATTR_T + 56 + + ) + +27  + #__SIZEOF_PTHREAD_MUTEX_T + 40 + + ) + +28  + #__SIZEOF_PTHREAD_MUTEXATTR_T + 4 + + ) + +29  + #__SIZEOF_PTHREAD_COND_T + 48 + + ) + +30  + #__SIZEOF_PTHREAD_CONDATTR_T + 4 + + ) + +31  + #__SIZEOF_PTHREAD_RWLOCK_T + 56 + + ) + +32  + #__SIZEOF_PTHREAD_RWLOCKATTR_T + 8 + + ) + +33  + #__SIZEOF_PTHREAD_BARRIER_T + 32 + + ) + +34  + #__SIZEOF_PTHREAD_BARRIERATTR_T + 4 + + ) + +36  + #__SIZEOF_PTHREAD_ATTR_T + 36 + + ) + +37  + #__SIZEOF_PTHREAD_MUTEX_T + 24 + + ) + +38  + #__SIZEOF_PTHREAD_MUTEXATTR_T + 4 + + ) + +39  + #__SIZEOF_PTHREAD_COND_T + 48 + + ) + +40  + #__SIZEOF_PTHREAD_CONDATTR_T + 4 + + ) + +41  + #__SIZEOF_PTHREAD_RWLOCK_T + 32 + + ) + +42  + #__SIZEOF_PTHREAD_RWLOCKATTR_T + 8 + + ) + +43  + #__SIZEOF_PTHREAD_BARRIER_T + 20 + + ) + +44  + #__SIZEOF_PTHREAD_BARRIERATTR_T + 4 + + ) + +50  + thad_t +; + +55  + m__size +[ +__SIZEOF_PTHREAD_ATTR_T +]; + +56  + m__ign +; + +57 } + thad__t +; + +60 #i +__WORDSIZE + == 64 + +61  + s__had__li + + +63  +__had__li + * + m__ev +; + +64  +__had__li + * + m__xt +; + +65 } + t__had_li_t +; + +67  + s__had__i + + +69  +__had__i + * + m__xt +; + +70 } + t__had_i_t +; + +78  + s__had_mux_s + + +80  + m__lock +; + +81  + m__cou +; + +82  + m__owr +; + +83 #i +__WORDSIZE + == 64 + +84  + m__nurs +; + +88  + m__kd +; + +89 #i +__WORDSIZE + == 64 + +90  + m__s +; + +91 +__had_li_t + + m__li +; + +92  + #__PTHREAD_MUTEX_HAVE_PREV + 1 + + ) + +94  + m__nurs +; + +95 +__exnsi__ + union + +97  + m__s +; + +98 +__had_i_t + + m__li +; + +101 } + m__da +; + +102  + m__size +[ +__SIZEOF_PTHREAD_MUTEX_T +]; + +103  + m__ign +; + +104 } + thad_mux_t +; + +108  + m__size +[ +__SIZEOF_PTHREAD_MUTEXATTR_T +]; + +109  + m__ign +; + +110 } + thad_mux_t +; + +119  + m__lock +; + +120  + m__fux +; + +121 +__exnsi__ +  + m__tٮ_q +; + +122 +__exnsi__ +  + m__wakeup_q +; + +123 +__exnsi__ +  + m__wok_q +; + +124 * + m__mux +; + +125  + m__nwas +; + +126  + m__brd_q +; + +127 } + m__da +; + +128  + m__size +[ +__SIZEOF_PTHREAD_COND_T +]; + +129 +__exnsi__ +  + m__ign +; + +130 } + thad_cd_t +; + +134  + m__size +[ +__SIZEOF_PTHREAD_CONDATTR_T +]; + +135  + m__ign +; + +136 } + thad_cd_t +; + +140  + thad_key_t +; + +144  + thad__t +; + +147 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +152 #i +__WORDSIZE + == 64 + +155  + m__lock +; + +156  + m___ads +; + +157  + m__ads_wakeup +; + +158  + m__wr_wakeup +; + +159  + m___ads_queued +; + +160  + m___wrs_queued +; + +161  + m__wr +; + +162  + m__shed +; + +163  + m__d1 +; + +164  + m__d2 +; + +167  + m__ags +; + +168 } + m__da +; + +172  + m__lock +; + +173  + m___ads +; + +174  + m__ads_wakeup +; + +175  + m__wr_wakeup +; + +176  + m___ads_queued +; + +177  + m___wrs_queued +; + +180  + m__ags +; + +181  + m__shed +; + +182  + m__d1 +; + +183  + m__d2 +; + +184  + m__wr +; + +185 } + m__da +; + +187  + m__size +[ +__SIZEOF_PTHREAD_RWLOCK_T +]; + +188  + m__ign +; + +189 } + thad_rwlock_t +; + +193  + m__size +[ +__SIZEOF_PTHREAD_RWLOCKATTR_T +]; + +194  + m__ign +; + +195 } + thad_rwlock_t +; + +199 #ifde +__USE_XOPEN2K + + +201 vީ + thad_lock_t +; + +208  + m__size +[ +__SIZEOF_PTHREAD_BARRIER_T +]; + +209  + m__ign +; + +210 } + thad_brr_t +; + +214  + m__size +[ +__SIZEOF_PTHREAD_BARRIERATTR_T +]; + +215  + m__ign +; + +216 } + thad_brr_t +; + +220 #i +__WORDSIZE + == 32 + +222  + #__nup_f_ibu + + `__ibu__ + (( + `__grm__ + (1))) + + ) + + @/usr/include/bits/setjmp.h + +20 #ide +_BITS_SETJMP_H + + +21  + #_BITS_SETJMP_H + 1 + + ) + +23 #i! +defed + +_SETJMP_H + && !defed +_PTHREAD_H + + +27  + ~ + +29 #ide +_ASM + + +31 #i +__WORDSIZE + == 64 + +32  + t__jmp_buf +[8]; + +34  + t__jmp_buf +[6]; + + @/usr/include/sched.h + +20 #idef +_SCHED_H + + +21  + #_SCHED_H + 1 + + ) + +23  + ~ + +26  + ~ + +28  + #__ed_size_t + + + ) + +29  + ~ + +31  + #__ed_timeec + + + ) + +32  + ~ + +35  + ~ + +37  + #sched_iܙy + +__sched_iܙy + + + ) + +40 +__BEGIN_DECLS + + +43  + $sched_am + ( +__pid_t + +__pid +, +__cڡ +  +sched_m + * +__m +) + +44 +__THROW +; + +47  + $sched_gm + ( +__pid_t + +__pid +,  +sched_m + * +__m + +__THROW +; + +50  + $sched_tschedur + ( +__pid_t + +__pid +,  +__picy +, + +51 +__cڡ +  +sched_m + * +__m + +__THROW +; + +54  + $sched_gschedur + ( +__pid_t + +__pid + +__THROW +; + +57  + $sched_yld + ( +__THROW +; + +60  + $sched_g_iܙy_max + ( +__gܙhm + +__THROW +; + +63  + $sched_g_iܙy_m + ( +__gܙhm + +__THROW +; + +66  + $sched__g_rv + ( +__pid_t + +__pid +,  +timeec + * +__t + +__THROW +; + +69 #ifde +__USE_GNU + + +71  + #CPU_SETSIZE + +__CPU_SETSIZE + + + ) + +72  + #CPU_SET +( +u +, +u + + `__CPU_SET_S + (u,  ( +u_t_t +), cpu) + + ) + +73  + #CPU_CLR +( +u +, +u + + `__CPU_CLR_S + (u,  ( +u_t_t +), cpu) + + ) + +74  + #CPU_ISSET +( +u +, +u + + `__CPU_ISSET_S + (u,  ( +u_t_t +), \ + +75 +u +) + + ) + +76  + #CPU_ZERO +( +u + + `__CPU_ZERO_S + ( ( +u_t_t +), cpu) + + ) + +77  + #CPU_COUNT +( +u + + `__CPU_COUNT_S + ( ( +u_t_t +), cpu) + + ) + +79  + #CPU_SET_S +( +u +, +tsize +, +u + + `__CPU_SET_S + (u, ssize, cpu) + + ) + +80  + #CPU_CLR_S +( +u +, +tsize +, +u + + `__CPU_CLR_S + (u, ssize, cpu) + + ) + +81  + #CPU_ISSET_S +( +u +, +tsize +, +u + + `__CPU_ISSET_S + (cpu, setsize, \ + +82 +u +) + + ) + +83  + #CPU_ZERO_S +( +tsize +, +u + + `__CPU_ZERO_S + (tsize, cpu) + + ) + +84  + #CPU_COUNT_S +( +tsize +, +u + + `__CPU_COUNT_S + (tsize, cpu) + + ) + +86  + #CPU_EQUAL +( +u1 +, +u2 +) \ + +87 + `__CPU_EQUAL_S + ( ( +u_t_t +), +u1 +, +u2 +) + + ) + +88  + #CPU_EQUAL_S +( +tsize +, +u1 +, +u2 +) \ + +89 + `__CPU_EQUAL_S + ( +tsize +, +u1 +, +u2 +) + + ) + +91  + #CPU_AND +( +det +, +ct1 +, +ct2 +) \ + +92 + `__CPU_OP_S + ( ( +u_t_t +), +det +, +ct1 +, +ct2 +, &) + + ) + +93  + #CPU_OR +( +det +, +ct1 +, +ct2 +) \ + +94 + `__CPU_OP_S + ( ( +u_t_t +), +det +, +ct1 +, +ct2 +, |) + + ) + +95  + #CPU_XOR +( +det +, +ct1 +, +ct2 +) \ + +96 + `__CPU_OP_S + ( ( +u_t_t +), +det +, +ct1 +, +ct2 +, ^) + + ) + +97  + #CPU_AND_S +( +tsize +, +det +, +ct1 +, +ct2 +) \ + +98 + `__CPU_OP_S + ( +tsize +, +det +, +ct1 +, +ct2 +, &) + + ) + +99  + #CPU_OR_S +( +tsize +, +det +, +ct1 +, +ct2 +) \ + +100 + `__CPU_OP_S + ( +tsize +, +det +, +ct1 +, +ct2 +, |) + + ) + +101  + #CPU_XOR_S +( +tsize +, +det +, +ct1 +, +ct2 +) \ + +102 + `__CPU_OP_S + ( +tsize +, +det +, +ct1 +, +ct2 +, ^) + + ) + +104  + #CPU_ALLOC_SIZE +( +cou + + `__CPU_ALLOC_SIZE + (cou) + + ) + +105  + #CPU_ALLOC +( +cou + + `__CPU_ALLOC + (cou) + + ) + +106  + #CPU_FREE +( +ut + + `__CPU_FREE + (ut) + + ) + +110  + $sched_ffy + ( +__pid_t + +__pid +, +size_t + +__utsize +, + +111 +__cڡ + +u_t_t + * +__ut + +__THROW +; + +114  + $sched_gaffy + ( +__pid_t + +__pid +, +size_t + +__utsize +, + +115 +u_t_t + * +__ut + +__THROW +; + +118 +__END_DECLS + + + @/usr/include/signal.h + +23 #idef +_SIGNAL_H + + +25 #i! +defed + +__ed_sig_omic_t + && !defed +__ed_sigt_t + + +26  + #_SIGNAL_H + + + ) + +29  + ~ + +31 + g__BEGIN_DECLS + + +33  + ~ + +37 #i +defed + +__ed_sig_omic_t + || defed +_SIGNAL_H + + +38 #ide +__sig_omic_t_defed + + +39  + #__sig_omic_t_defed + + + ) + +40 +__BEGIN_NAMESPACE_STD + + +41  +__sig_omic_t + + tsig_omic_t +; + +42 + g__END_NAMESPACE_STD + + +44 #unde +__ed_sig_omic_t + + +47 #i +defed + +__ed_sigt_t + || (defed +_SIGNAL_H + && defed +__USE_POSIX +) + +48 #ide +__sigt_t_defed + + +49  + #__sigt_t_defed + + + ) + +50  +__sigt_t + + tsigt_t +; + +52 #unde +__ed_sigt_t + + +55 #ifde +_SIGNAL_H + + +57  + ~ + +58  + ~ + +60 #i +defed + +__USE_XOPEN + || defed +__USE_XOPEN2K + + +61 #ide +__pid_t_defed + + +62  +__pid_t + + tpid_t +; + +63  + #__pid_t_defed + + + ) + +65 #ifde +__USE_XOPEN + + +67 #ide +__uid_t_defed + + +68  +__uid_t + + tuid_t +; + +69  + #__uid_t_defed + + + ) + +73 #ifde +__USE_POSIX199309 + + +75  + #__ed_timeec + + + ) + +76  + ~ + +79  + ~ + +84 (* + t__sighdr_t +) (); + +89 +__sighdr_t + + $__sysv_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +90 +__THROW +; + +91 #ifde +__USE_GNU + + +92 +__sighdr_t + + $sysv_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +93 +__THROW +; + +99 +__BEGIN_NAMESPACE_STD + + +100 #ifde +__USE_BSD + + +101 +__sighdr_t + + $sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +102 +__THROW +; + +105 #ifde +__REDIRECT_NTH + + +106 +__sighdr_t + + `__REDIRECT_NTH + ( +sigl +, + +107 ( +__sig +, +__sighdr_t + +__hdr +), + +108 +__sysv_sigl +); + +110  + #sigl + +__sysv_sigl + + + ) + +113 +__END_NAMESPACE_STD + + +115 #ifde +__USE_XOPEN + + +118 +__sighdr_t + + $bsd_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +119 +__THROW +; + +125 #ifde +__USE_POSIX + + +126  + $kl + ( +__pid_t + +__pid +,  +__sig + +__THROW +; + +129 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +133  + $kg + ( +__pid_t + +__pg +,  +__sig + +__THROW +; + +136 +__BEGIN_NAMESPACE_STD + + +138  + $i + ( +__sig + +__THROW +; + +139 +__END_NAMESPACE_STD + + +141 #ifde +__USE_SVID + + +143 +__sighdr_t + + $ssigl + ( +__sig +, +__sighdr_t + +__hdr +) + +144 +__THROW +; + +145  + $gsigl + ( +__sig + +__THROW +; + +148 #i +defed + +__USE_MISC + || defed +__USE_XOPEN2K + + +150  + `psigl + ( +__sig +, +__cڡ + * +__s +); + +153 #ifde +__USE_XOPEN2K + + +155  + `psigfo + ( +__cڡ + +sigfo_t + * +__pfo +, __cڡ * +__s +); + +168  + `__sigu + ( +__sig__mask +,  +__is_sig +); + +170 #ifde +__FAVOR_BSD + + +173  + $sigu + ( +__mask + +__THROW + +__ibu_dd__ +; + +175 #ifde +__USE_XOPEN + + +176 #ifde +__GNUC__ + + +177  + $sigu + ( +__sig + + `__asm__ + ("__xpg_sigpause"); + +180  + #sigu +( +sig + + `__sigu + ((sig), 1) + + ) + +186 #ifde +__USE_BSD + + +193  + #sigmask +( +sig + + `__sigmask +(sig) + + ) + +196  + $sigblock + ( +__mask + +__THROW + +__ibu_dd__ +; + +199  + $sigtmask + ( +__mask + +__THROW + +__ibu_dd__ +; + +202  + $siggmask + ( +__THROW + +__ibu_dd__ +; + +206 #ifde +__USE_MISC + + +207  + #NSIG + +_NSIG + + + ) + +210 #ifde +__USE_GNU + + +211  +__sighdr_t + + tsighdr_t +; + +215 #ifde +__USE_BSD + + +216  +__sighdr_t + + tsig_t +; + +219 #ifde +__USE_POSIX + + +222  + $sigemyt + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +225  + $sigflt + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +228  + $sigaddt + ( +sigt_t + * +__t +,  +__signo + +__THROW + + `__nnu + ((1)); + +231  + $sigdt + ( +sigt_t + * +__t +,  +__signo + +__THROW + + `__nnu + ((1)); + +234  + $sigismemb + ( +__cڡ + +sigt_t + * +__t +,  +__signo +) + +235 +__THROW + + `__nnu + ((1)); + +237 #ifde +__USE_GNU + + +239  + $sigimyt + ( +__cڡ + +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +242  + $sigdt + ( +sigt_t + * +__t +, +__cڡ + sigt_* +__ +, + +243 +__cڡ + +sigt_t + * +__right + +__THROW + + `__nnu + ((1, 2, 3)); + +246  + $sigܣt + ( +sigt_t + * +__t +, +__cڡ + sigt_* +__ +, + +247 +__cڡ + +sigt_t + * +__right + +__THROW + + `__nnu + ((1, 2, 3)); + +252  + ~ + +255  + $sigocmask + ( +__how +, +__cڡ + +sigt_t + * +__ri + +__t +, + +256 +sigt_t + * +__ri + +__ot + +__THROW +; + +263  + $sigsud + ( +__cڡ + +sigt_t + * +__t + + `__nnu + ((1)); + +266  + $sigai + ( +__sig +, +__cڡ +  +sigai + * +__ri + +__a +, + +267  +sigai + * +__ri + +__ + +__THROW +; + +270  + $signdg + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +277  + $sigwa + ( +__cڡ + +sigt_t + * +__ri + +__t +, *__ri +__sig +) + +278 + `__nnu + ((1, 2)); + +280 #ifde +__USE_POSIX199309 + + +285  + $sigwafo + ( +__cڡ + +sigt_t + * +__ri + +__t +, + +286 +sigfo_t + * +__ri + +__fo + + `__nnu + ((1)); + +293  + $sigtimedwa + ( +__cڡ + +sigt_t + * +__ri + +__t +, + +294 +sigfo_t + * +__ri + +__fo +, + +295 +__cڡ +  +timeec + * +__ri + +__timeout +) + +296 + `__nnu + ((1)); + +300  + $sigqueue + ( +__pid_t + +__pid +,  +__sig +, +__cڡ +  +sigv + +__v +) + +301 +__THROW +; + +306 #ifde +__USE_BSD + + +310 +__cڡ + *__cڡ +_sys_sigli +[ +_NSIG +]; + +311 +__cڡ + *__cڡ +sys_sigli +[ +_NSIG +]; + +314  + ssigvec + + +316 +__sighdr_t + +sv_hdr +; + +317  +sv_mask +; + +319  +sv_ags +; + +320  + #sv_ڡack + +sv_ags + + + ) + +324  + #SV_ONSTACK + (1 << 0) + + ) + +325  + #SV_INTERRUPT + (1 << 1) + + ) + +326  + #SV_RESETHAND + (1 << 2) + + ) + +334  + $sigvec + ( +__sig +, +__cڡ +  +sigvec + * +__vec +, + +335  +sigvec + * +__ovec + +__THROW +; + +339  + ~ + +342  + $sigtu + ( +sigcڋxt + * +__s + +__THROW +; + +347 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +348  + #__ed_size_t + + + ) + +349  + ~ + +354  + $sigu + ( +__sig +,  +__u + +__THROW +; + +356  + ~ + +357 #ifde +__USE_XOPEN + + +359  + ~ + +365  + $sigack + ( +sigack + * +__ss +, sigack * +__oss +) + +366 +__THROW + +__ibu_dd__ +; + +370  + $sigtack + ( +__cڡ +  +sigtack + * +__ri + +__ss +, + +371  +sigtack + * +__ri + +__oss + +__THROW +; + +375 #ifde +__USE_XOPEN_EXTENDED + + +379  + $sighd + ( +__sig + +__THROW +; + +382  + $sigl + ( +__sig + +__THROW +; + +385  + $sigigne + ( +__sig + +__THROW +; + +388 +__sighdr_t + + $sigt + ( +__sig +, +__sighdr_t + +__di + +__THROW +; + +391 #i +defed + +__USE_POSIX199506 + || defed +__USE_UNIX98 + + +394  + ~ + +395  + ~ + +402  + $__libc_cut_sigm + ( +__THROW +; + +404  + $__libc_cut_sigmax + ( +__THROW +; + +408 +__END_DECLS + + + @/usr/include/time.h + +23 #idef +_TIME_H + + +25 #i(! +defed + +__ed_time_t + && !defed +__ed_ock_t + && \ + +26 ! +defed + + g__ed_timeec +) + +27  + #_TIME_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +34 #ifdef +_TIME_H + + +36  + #__ed_size_t + + + ) + +37  + #__ed_NULL + + + ) + +38  + ~ + +42  + ~ + +45 #i! +defed + +__STRICT_ANSI__ + && !defed +__USE_XOPEN2K + + +46 #ide +CLK_TCK + + +47  + #CLK_TCK + +CLOCKS_PER_SEC + + + ) + +53 #i! +defed + +__ock_t_defed + && (defed +_TIME_H + || defed +__ed_ock_t +) + +54  + #__ock_t_defed + 1 + + ) + +56  + ~ + +58 +__BEGIN_NAMESPACE_STD + + +60  +__ock_t + + tock_t +; + +61 + g__END_NAMESPACE_STD + + +62 #i +defed + +__USE_XOPEN + || defed +__USE_POSIX + || defed +__USE_MISC + + +63 + $__USING_NAMESPACE_STD +( +ock_t +) + +67 #unde +__ed_ock_t + + +69 #i! +defed + +__time_t_defed + && (defed +_TIME_H + || defed +__ed_time_t +) + +70  + #__time_t_defed + 1 + + ) + +72  + ~ + +74 +__BEGIN_NAMESPACE_STD + + +76  +__time_t + + ttime_t +; + +77 +__END_NAMESPACE_STD + + +78 #i +defed + +__USE_POSIX + || defed +__USE_MISC + || defed +__USE_SVID + + +79 + $__USING_NAMESPACE_STD +( +time_t +) + +83 #unde +__ed_time_t + + +85 #i! +defed + +__ockid_t_defed + && \ + +86 (( +defed + +_TIME_H + && defed +__USE_POSIX199309 +|| defed +__ed_ockid_t +) + +87  + #__ockid_t_defed + 1 + + ) + +89  + ~ + +92  +__ockid_t + + tockid_t +; + +95 #unde +__ockid_time_t + + +97 #i! +defed + +__tim_t_defed + && \ + +98 (( +defed + +_TIME_H + && defed +__USE_POSIX199309 +|| defed +__ed_tim_t +) + +99  + #__tim_t_defed + 1 + + ) + +101  + ~ + +104  +__tim_t + + ttim_t +; + +107 #unde +__ed_tim_t + + +110 #i! +defed + +__timeec_defed + && \ + +111 (( +defed + +_TIME_H + && \ + +112 ( +defed + +__USE_POSIX199309 + || defed +__USE_MISC +)) || \ + +113 +defed + +__ed_timeec +) + +114  + #__timeec_defed + 1 + + ) + +116  + ~ + +120  + stimeec + + +122 +__time_t + +tv_c +; + +123  +tv_nc +; + +127 #unde +__ed_timeec + + +130 #ifdef +_TIME_H + + +131 +__BEGIN_NAMESPACE_STD + + +133  + stm + + +135  +tm_c +; + +136  +tm_m +; + +137  +tm_hour +; + +138  +tm_mday +; + +139  +tm_m +; + +140  +tm_yr +; + +141  +tm_wday +; + +142  +tm_yday +; + +143  +tm_isd +; + +145 #ifdef +__USE_BSD + + +146  +tm_gmtoff +; + +147 +__cڡ + * +tm_ze +; + +149  +__tm_gmtoff +; + +150 +__cڡ + * +__tm_ze +; + +153 +__END_NAMESPACE_STD + + +154 #i +defed + +__USE_XOPEN + || defed +__USE_POSIX + || defed +__USE_MISC + + +155 + $__USING_NAMESPACE_STD +( +tm +) + +159 #ifde +__USE_POSIX199309 + + +161  + simec + + +163  +timeec + +_rv +; + +164  +timeec + +_vue +; + +168  +sigevt +; + +172 #ifde +__USE_XOPEN2K + + +173 #ide +__pid_t_defed + + +174  +__pid_t + + tpid_t +; + +175  + #__pid_t_defed + + + ) + +180 +__BEGIN_NAMESPACE_STD + + +183 +ock_t + + $ock + ( +__THROW +; + +186 +time_t + + $time + ( +time_t + * +__tim + +__THROW +; + +189  + $difime + ( +time_t + +__time1 +,ime_ +__time0 +) + +190 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +193 +time_t + + $mktime + ( +tm + * +__ + +__THROW +; + +199 +size_t + + $rime + (* +__ri + +__s +, +size_t + +__maxsize +, + +200 +__cڡ + * +__ri + +__fm +, + +201 +__cڡ +  +tm + * +__ri + +__ + +__THROW +; + +202 +__END_NAMESPACE_STD + + +204 #ifde +__USE_XOPEN + + +207 * + $time + ( +__cڡ + * +__ri + +__s +, + +208 +__cڡ + * +__ri + +__fmt +,  +tm + * +__ +) + +209 +__THROW +; + +212 #ifde +__USE_XOPEN2K8 + + +215  + ~ + +217 +size_t + + $rime_l + (* +__ri + +__s +, +size_t + +__maxsize +, + +218 +__cڡ + * +__ri + +__fm +, + +219 +__cڡ +  +tm + * +__ri + +__ +, + +220 +__lo_t + +__loc + +__THROW +; + +223 #ifde +__USE_GNU + + +224 * + $time_l + ( +__cڡ + * +__ri + +__s +, + +225 +__cڡ + * +__ri + +__fmt +,  +tm + * +__ +, + +226 +__lo_t + +__loc + +__THROW +; + +230 +__BEGIN_NAMESPACE_STD + + +233  +tm + * + $gmtime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +237  +tm + * + $loime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +238 +__END_NAMESPACE_STD + + +240 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +243  +tm + * + $gmtime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +244  +tm + * +__ri + +__ + +__THROW +; + +248  +tm + * + $loime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +249  +tm + * +__ri + +__ + +__THROW +; + +252 +__BEGIN_NAMESPACE_STD + + +255 * + $asime + ( +__cڡ +  +tm + * +__ + +__THROW +; + +258 * + $ime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +259 +__END_NAMESPACE_STD + + +261 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +266 * + $asime_r + ( +__cڡ +  +tm + * +__ri + +__ +, + +267 * +__ri + +__buf + +__THROW +; + +270 * + $ime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +271 * +__ri + +__buf + +__THROW +; + +276 * +__tzme +[2]; + +277  +__daylight +; + +278  +__timeze +; + +281 #ifdef +__USE_POSIX + + +283 * +tzme +[2]; + +287  + $tzt + ( +__THROW +; + +290 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +291  +daylight +; + +292  +timeze +; + +295 #ifde +__USE_SVID + + +298  + $ime + ( +__cڡ + +time_t + * +__wh + +__THROW +; + +304  + #__ip +( +yr +) \ + +305 (( +yr +% 4 =0 && ((yr% 100 !0 || (yr% 400 =0)) + + ) + +308 #ifde +__USE_MISC + + +313 +time_t + + $timegm + ( +tm + * +__ + +__THROW +; + +316 +time_t + + $timol + ( +tm + * +__ + +__THROW +; + +319  + $dysize + ( +__yr + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +323 #ifde +__USE_POSIX199309 + + +328  + `nop + ( +__cڡ +  +timeec + * +__queed_time +, + +329  +timeec + * +__mag +); + +333  + $ock_gs + ( +ockid_t + +__ock_id +,  +timeec + * +__s + +__THROW +; + +336  + $ock_gtime + ( +ockid_t + +__ock_id +,  +timeec + * +__ + +__THROW +; + +339  + $ock_ime + ( +ockid_t + +__ock_id +, +__cڡ +  +timeec + * +__ +) + +340 +__THROW +; + +342 #ifde +__USE_XOPEN2K + + +347  + `ock_nop + ( +ockid_t + +__ock_id +,  +__ags +, + +348 +__cڡ +  +timeec + * +__q +, + +349  +timeec + * +__m +); + +352  + $ock_guockid + ( +pid_t + +__pid +, +ockid_t + * +__ock_id + +__THROW +; + +357  + $tim_ + ( +ockid_t + +__ock_id +, + +358  +sigevt + * +__ri + +__evp +, + +359 +tim_t + * +__ri + +__timid + +__THROW +; + +362  + $tim_de + ( +tim_t + +__timid + +__THROW +; + +365  + $tim_ime + ( +tim_t + +__timid +,  +__ags +, + +366 +__cڡ +  +imec + * +__ri + +__vue +, + +367  +imec + * +__ri + +__ovue + +__THROW +; + +370  + $tim_gtime + ( +tim_t + +__timid +,  +imec + * +__vue +) + +371 +__THROW +; + +374  + $tim_govrun + ( +tim_t + +__timid + +__THROW +; + +378 #ifde +__USE_XOPEN_EXTENDED + + +390  +gde_r +; + +399  +tm + * + `gde + ( +__cڡ + * +__rg +); + +402 #ifde +__USE_GNU + + +413  + `gde_r + ( +__cڡ + * +__ri + +__rg +, + +414  +tm + * +__ri + +__sbu +); + +417 +__END_DECLS + + + @/usr/include/bits/sched.h + +22 #ide +__ed_schedm + + +24 #ide +_SCHED_H + + +30  + #SCHED_OTHER + 0 + + ) + +31  + #SCHED_FIFO + 1 + + ) + +32  + #SCHED_RR + 2 + + ) + +33 #ifde +__USE_GNU + + +34  + #SCHED_BATCH + 3 + + ) + +37 #ifde +__USE_MISC + + +39  + #CSIGNAL + 0x000000f + + ) + +40  + #CLONE_VM + 0x00000100 + + ) + +41  + #CLONE_FS + 0x00000200 + + ) + +42  + #CLONE_FILES + 0x00000400 + + ) + +43  + #CLONE_SIGHAND + 0x00000800 + + ) + +44  + #CLONE_PTRACE + 0x00002000 + + ) + +45  + #CLONE_VFORK + 0x00004000 + + ) + +47  + #CLONE_PARENT + 0x00008000 + + ) + +49  + #CLONE_THREAD + 0x00010000 + + ) + +50  + #CLONE_NEWNS + 0x00020000 + + ) + +51  + #CLONE_SYSVSEM + 0x00040000 + + ) + +52  + #CLONE_SETTLS + 0x00080000 + + ) + +53  + #CLONE_PARENT_SETTID + 0x00100000 + + ) + +55  + #CLONE_CHILD_CLEARTID + 0x00200000 + + ) + +57  + #CLONE_DETACHED + 0x00400000 + + ) + +58  + #CLONE_UNTRACED + 0x00800000 + + ) + +60  + #CLONE_CHILD_SETTID + 0x01000000 + + ) + +62  + #CLONE_NEWUTS + 0x04000000 + + ) + +63  + #CLONE_NEWIPC + 0x08000000 + + ) + +64  + #CLONE_NEWUSER + 0x10000000 + + ) + +65  + #CLONE_NEWPID + 0x20000000 + + ) + +66  + #CLONE_NEWNET + 0x40000000 + + ) + +67  + #CLONE_IO + 0x80000000 + + ) + +71  + ssched_m + + +73  + m__sched_iܙy +; + +76 + g__BEGIN_DECLS + + +78 #ifde +__USE_MISC + + +80  +e + ((* +__ +(* +__g +), * +__chd_ack +, + +81  +__ags +, * +__g +, ... +__THROW +; + +84  + $unshe + ( +__ags + +__THROW +; + +87  + $sched_gu + ( +__THROW +; + +90 +__END_DECLS + + +94 #i! +defed + +__defed_schedm + \ + +95 && ( +defed + +__ed_schedm + || defed +_SCHED_H +) + +96  + #__defed_schedm + 1 + + ) + +98  + s__sched_m + + +100  +__sched_iܙy +; + +102 #unde +__ed_schedm + + +106 #i +defed + +_SCHED_H + && !defed +__u_t_t_defed + + +107  + #__u_t_t_defed + + + ) + +109  + #__CPU_SETSIZE + 1024 + + ) + +110  + #__NCPUBITS + (8 *  ( +__u_mask +)) + + ) + +113  + t__u_mask +; + +116  + #__CPUELT +( +u +((u/ +__NCPUBITS +) + + ) + +117  + #__CPUMASK +( +u +(( +__u_mask +1 << ((u% +__NCPUBITS +)) + + ) + +122 +__u_mask + +__bs +[ +__CPU_SETSIZE + / +__NCPUBITS +]; + +123 } + tu_t_t +; + +126 #i + `__GNUC_PREREQ + (2, 91) + +127  + #__CPU_ZERO_S +( +tsize +, +u +) \ + +128 d + `__but_memt + ( +u +, '\0', +tsize +); 0) + + ) + +130  + #__CPU_ZERO_S +( +tsize +, +u +) \ + +132 +size_t + +__i +; \ + +133 +size_t + +__imax + = ( +tsize +/  ( +__u_mask +); \ + +134 +__u_mask + * +__bs + = ( +u +)->__bits; \ + +135  +__i + = 0; __< +__imax +; ++__i) \ + +136 +__bs +[ +__i +] = 0; \ + +137 + } +} 0) + + ) + +139  + #__CPU_SET_S +( +u +, +tsize +, +u +) \ + +140 ( +__exnsi__ + \ + +141 ({ +size_t + +__u + = ( +u +); \ + +142 +__u + < 8 * ( +tsize +) \ + +143 ? ((( +__u_mask + *(( +u +)-> +__bs +))[ + `__CPUELT + ( +__u +)] \ + +144 | + `__CPUMASK + ( +__u +)) \ + +145 : 0; })) + + ) + +146  + #__CPU_CLR_S +( +u +, +tsize +, +u +) \ + +147 ( +__exnsi__ + \ + +148 ({ +size_t + +__u + = ( +u +); \ + +149 +__u + < 8 * ( +tsize +) \ + +150 ? ((( +__u_mask + *(( +u +)-> +__bs +))[ + `__CPUELT + ( +__u +)] \ + +151 &~ + `__CPUMASK + ( +__u +)) \ + +152 : 0; })) + + ) + +153  + #__CPU_ISSET_S +( +u +, +tsize +, +u +) \ + +154 ( +__exnsi__ + \ + +155 ({ +size_t + +__u + = ( +u +); \ + +156 +__u + < 8 * ( +tsize +) \ + +157 ? (((( +__cڡ + +__u_mask + *(( +u +)-> +__bs +))[ + `__CPUELT + ( +__u +)] \ + +158 & + `__CPUMASK + ( +__u +))) != 0 \ + +159 : 0; })) + + ) + +161  + #__CPU_COUNT_S +( +tsize +, +u +) \ + +162 + `__sched_ucou + ( +tsize +, +u +) + + ) + +164 #i +__GNUC_PREREQ + (2, 91) + +165  + #__CPU_EQUAL_S +( +tsize +, +u1 +, +u2 +) \ + +166 ( + `__but_memcmp + ( +u1 +, +u2 +, +tsize +=0) + + ) + +168  + #__CPU_EQUAL_S +( +tsize +, +u1 +, +u2 +) \ + +169 ( +__exnsi__ + \ + +170 ({ +__cڡ + +__u_mask + * +__r1 + = ( +u1 +)-> +__bs +; \ + +171 +__cڡ + +__u_mask + * +__r2 + = ( +u2 +)-> +__bs +; \ + +172 +size_t + +__imax + = ( +tsize +/  ( +__u_mask +); \ + +173 +size_t + +__i +; \ + +174  +__i + = 0; __< +__imax +; ++__i) \ + +175 i( +__bs +[ +__i +] != __bits[__i]) \ + +177 +__i + = +__imax +; })) + + ) + +180  + #__CPU_OP_S +( +tsize +, +det +, +ct1 +, +ct2 +, + +) \ + +181 ( +__exnsi__ + \ + +182 ({ +u_t_t + * +__de + = ( +det +); \ + +183 +__cڡ + +__u_mask + * +__r1 + = ( +ct1 +)-> +__bs +; \ + +184 +__cڡ + +__u_mask + * +__r2 + = ( +ct2 +)-> +__bs +; \ + +185 +size_t + +__imax + = ( +tsize +/  ( +__u_mask +); \ + +186 +size_t + +__i +; \ + +187  +__i + = 0; __< +__imax +; ++__i) \ + +188 (( +__u_mask + * +__de +-> +__bs +)[ +__i +] = +__r1 +[__i] + + +__r2 +[__i]; \ + +189 +__de +; })) + + ) + +191  + #__CPU_ALLOC_SIZE +( +cou +) \ + +192 (((( +cou ++ +__NCPUBITS + - 1/ __NCPUBITS*  ( +__u_mask +)) + + ) + +193  + #__CPU_ALLOC +( +cou + + `__sched_uloc + (cou) + + ) + +194  + #__CPU_FREE +( +ut + + `__sched_u + (ut) + + ) + +196 +__BEGIN_DECLS + + +198  + $__sched_ucou + ( +size_t + +__tsize +, cڡ +u_t_t + * +__ +) + +199 +__THROW +; + +200 +u_t_t + * + $__sched_uloc + ( +size_t + +__cou + +__THROW + +__wur +; + +201  + $__sched_u + ( +u_t_t + * +__t + +__THROW +; + +203 +__END_DECLS + + + @/usr/include/bits/sigaction.h + +20 #ide +_SIGNAL_H + + +25  + ssigai + + +28 #ifde +__USE_POSIX199309 + + +32 +__sighdr_t + + m_hdr +; + +34 (* + m_sigai +(, + msigfo_t + *, *); + +36 + m__sigai_hdr +; + +37  + #_hdr + +__sigai_hdr +. +_hdr + + + ) + +38  + #_sigai + +__sigai_hdr +. +_sigai + + + ) + +40 +__sighdr_t + + m_hdr +; + +44 +__sigt_t + + m_mask +; + +47  + m_ags +; + +50 (* + m_ܔ +) (); + +54  + #SA_NOCLDSTOP + 1 + + ) + +55  + #SA_NOCLDWAIT + 2 + + ) + +56  + #SA_SIGINFO + 4 + + ) + +58 #i +defed + +__USE_UNIX98 + || defed +__USE_MISC + + +59  + #SA_ONSTACK + 0x08000000 + + ) + +60  + #SA_RESTART + 0x10000000 + + ) + +61  + #SA_NODEFER + 0x40000000 + + ) + +63  + #SA_RESETHAND + 0x80000000 + + ) + +65 #ifde +__USE_MISC + + +66  + #SA_INTERRUPT + 0x20000000 + + ) + +69  + #SA_NOMASK + +SA_NODEFER + + + ) + +70  + #SA_ONESHOT + +SA_RESETHAND + + + ) + +71  + #SA_STACK + +SA_ONSTACK + + + ) + +75  + #SIG_BLOCK + 0 + + ) + +76  + #SIG_UNBLOCK + 1 + + ) + +77  + #SIG_SETMASK + 2 + + ) + + @/usr/include/bits/sigcontext.h + +19 #ide +_BITS_SIGCONTEXT_H + + +20  + #_BITS_SIGCONTEXT_H + 1 + + ) + +22 #i! +defed + +_SIGNAL_H + && !defed +_SYS_UCONTEXT_H + + +26  + ~ + +28  + s_g + + +30  + msignifind +[4]; + +31  + mexpڒt +; + +34  + s_xg + + +36  + msignifind +[4]; + +37  + mexpڒt +; + +38  + mddg +[3]; + +41  + s_xmmg + + +43 +__ut32_t + + memt +[4]; + +48 #i +__WORDSIZE + == 32 + +50  + s_塩e + + +53 +__ut32_t + + mcw +; + +54 +__ut32_t + + msw +; + +55 +__ut32_t + + mg +; + +56 +__ut32_t + + moff +; + +57 +__ut32_t + + mcsl +; + +58 +__ut32_t + + mdaoff +; + +59 +__ut32_t + + mdal +; + +60  +_g + + m_ +[8]; + +61  + mus +; + +62  + mmagic +; + +65 +__ut32_t + + m_fx_v +[6]; + +66 +__ut32_t + + mmxc +; + +67 +__ut32_t + + mrved +; + +68  +_xg + + m_fx_ +[8]; + +69  +_xmmg + + m_xmm +[8]; + +70 +__ut32_t + + mddg +[56]; + +73 #ide +sigcڋxt_ru + + +78  + #sigcڋxt_ru + +sigcڋxt + + + ) + +81  + ssigcڋxt + + +83  + mgs +, + m__gsh +; + +84  + mfs +, + m__fsh +; + +85  + mes +, + m__esh +; + +86  + mds +, + m__dsh +; + +87  + medi +; + +88  + mesi +; + +89  + mebp +; + +90  + me +; + +91  + mebx +; + +92  + medx +; + +93  + mecx +; + +94  + mx +; + +95  + mno +; + +96  + mr +; + +97  + me +; + +98  + mcs +, + m__csh +; + +99  + meags +; + +100  + me__sigl +; + +101  + mss +, + m__ssh +; + +102  +_塩e + * + m塩e +; + +103  + mdmask +; + +104  + m2 +; + +109  + s_塩e + + +112 +__ut16_t + + mcwd +; + +113 +__ut16_t + + mswd +; + +114 +__ut16_t + + mw +; + +115 +__ut16_t + + mf +; + +116 +__ut64_t + + mr +; + +117 +__ut64_t + + mrdp +; + +118 +__ut32_t + + mmxc +; + +119 +__ut32_t + + mmx_mask +; + +120  +_xg + + m_ +[8]; + +121  +_xmmg + + m_xmm +[16]; + +122 +__ut32_t + + mddg +[24]; + +125  + ssigcڋxt + + +127  + mr8 +; + +128  + mr9 +; + +129  + mr10 +; + +130  + mr11 +; + +131  + mr12 +; + +132  + mr13 +; + +133  + mr14 +; + +134  + mr15 +; + +135  + mrdi +; + +136  + mrsi +; + +137  + mrbp +; + +138  + mrbx +; + +139  + mrdx +; + +140  + mx +; + +141  + mrcx +; + +142  + mr +; + +143  + mr +; + +144  + meags +; + +145  + mcs +; + +146  + mgs +; + +147  + mfs +; + +148  + m__d0 +; + +149  + mr +; + +150  + mno +; + +151  + mdmask +; + +152  + m2 +; + +153  +_塩e + * + m塩e +; + +154  + m__rved1 + [8]; + + @/usr/include/bits/siginfo.h + +20 #i! +defed + +_SIGNAL_H + && !defed +__ed_sigfo_t + \ + +21 && ! +defed + + g__ed_sigevt_t + + +25  + ~ + +27 #i(! +defed + +__have_sigv_t + \ + +28 && ( +defed + + g_SIGNAL_H + || defed + g__ed_sigfo_t + \ + +29 || +defed + + g__ed_sigevt_t +)) + +30  + #__have_sigv_t + 1 + + ) + +33  + usigv + + +35  + msiv_t +; + +36 * + msiv_r +; + +37 } + tsigv_t +; + +40 #i(! +defed + +__have_sigfo_t + \ + +41 && ( +defed + + g_SIGNAL_H + || defed + g__ed_sigfo_t +)) + +42  + #__have_sigfo_t + 1 + + ) + +44  + #__SI_MAX_SIZE + 128 + + ) + +45 #i +__WORDSIZE + == 64 + +46  + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + /  ()- 4) + + ) + +48  + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + /  ()- 3) + + ) + +51  + ssigfo + + +53  + msi_signo +; + +54  + msi_o +; + +56  + msi_code +; + +60  + m_d +[ +__SI_PAD_SIZE +]; + +65 +__pid_t + + msi_pid +; + +66 +__uid_t + + msi_uid +; + +67 } + m_kl +; + +72  + msi_tid +; + +73  + msi_ovrun +; + +74 +sigv_t + + msi_sigv +; + +75 } + m_tim +; + +80 +__pid_t + + msi_pid +; + +81 +__uid_t + + msi_uid +; + +82 +sigv_t + + msi_sigv +; + +83 } + m_ +; + +88 +__pid_t + + msi_pid +; + +89 +__uid_t + + msi_uid +; + +90  + msi_us +; + +91 +__ock_t + + msi_utime +; + +92 +__ock_t + + msi_ime +; + +93 } + m_sigchld +; + +98 * + msi_addr +; + +99 } + m_sigu +; + +104  + msi_bd +; + +105  + msi_fd +; + +106 } + m_sigpl +; + +107 } + m_siflds +; + +108 } + tsigfo_t +; + +112  + #si_pid + +_siflds +. +_kl +. +si_pid + + + ) + +113  + #si_uid + +_siflds +. +_kl +. +si_uid + + + ) + +114  + #si_timid + +_siflds +. +_tim +. +si_tid + + + ) + +115  + #si_ovrun + +_siflds +. +_tim +. +si_ovrun + + + ) + +116  + #si_us + +_siflds +. +_sigchld +. +si_us + + + ) + +117  + #si_utime + +_siflds +. +_sigchld +. +si_utime + + + ) + +118  + #si_ime + +_siflds +. +_sigchld +. +si_ime + + + ) + +119  + #si_vue + +_siflds +. +_ +. +si_sigv + + + ) + +120  + #si_t + +_siflds +. +_ +. +si_sigv +. +siv_t + + + ) + +121  + #si_r + +_siflds +. +_ +. +si_sigv +. +siv_r + + + ) + +122  + #si_addr + +_siflds +. +_sigu +. +si_addr + + + ) + +123  + #si_bd + +_siflds +. +_sigpl +. +si_bd + + + ) + +124  + #si_fd + +_siflds +. +_sigpl +. +si_fd + + + ) + +131 + mSI_ASYNCNL + = -60, + +132  + #SI_ASYNCNL + +SI_ASYNCNL + + + ) + +133 + mSI_TKILL + = -6, + +134  + #SI_TKILL + +SI_TKILL + + + ) + +135 + mSI_SIGIO +, + +136  + #SI_SIGIO + +SI_SIGIO + + + ) + +137 + mSI_ASYNCIO +, + +138  + #SI_ASYNCIO + +SI_ASYNCIO + + + ) + +139 + mSI_MESGQ +, + +140  + #SI_MESGQ + +SI_MESGQ + + + ) + +141 + mSI_TIMER +, + +142  + #SI_TIMER + +SI_TIMER + + + ) + +143 + mSI_QUEUE +, + +144  + #SI_QUEUE + +SI_QUEUE + + + ) + +145 + mSI_USER +, + +146  + #SI_USER + +SI_USER + + + ) + +147 + mSI_KERNEL + = 0x80 + +148  + #SI_KERNEL + +SI_KERNEL + + + ) + +155 + mILL_ILLOPC + = 1, + +156  + #ILL_ILLOPC + +ILL_ILLOPC + + + ) + +157 + mILL_ILLOPN +, + +158  + #ILL_ILLOPN + +ILL_ILLOPN + + + ) + +159 + mILL_ILLADR +, + +160  + #ILL_ILLADR + +ILL_ILLADR + + + ) + +161 + mILL_ILLTRP +, + +162  + #ILL_ILLTRP + +ILL_ILLTRP + + + ) + +163 + mILL_PRVOPC +, + +164  + #ILL_PRVOPC + +ILL_PRVOPC + + + ) + +165 + mILL_PRVREG +, + +166  + #ILL_PRVREG + +ILL_PRVREG + + + ) + +167 + mILL_COPROC +, + +168  + #ILL_COPROC + +ILL_COPROC + + + ) + +169 + mILL_BADSTK + + +170  + #ILL_BADSTK + +ILL_BADSTK + + + ) + +176 + mFPE_INTDIV + = 1, + +177  + #FPE_INTDIV + +FPE_INTDIV + + + ) + +178 + mFPE_INTOVF +, + +179  + #FPE_INTOVF + +FPE_INTOVF + + + ) + +180 + mFPE_FLTDIV +, + +181  + #FPE_FLTDIV + +FPE_FLTDIV + + + ) + +182 + mFPE_FLTOVF +, + +183  + #FPE_FLTOVF + +FPE_FLTOVF + + + ) + +184 + mFPE_FLTUND +, + +185  + #FPE_FLTUND + +FPE_FLTUND + + + ) + +186 + mFPE_FLTRES +, + +187  + #FPE_FLTRES + +FPE_FLTRES + + + ) + +188 + mFPE_FLTINV +, + +189  + #FPE_FLTINV + +FPE_FLTINV + + + ) + +190 + mFPE_FLTSUB + + +191  + #FPE_FLTSUB + +FPE_FLTSUB + + + ) + +197 + mSEGV_MAPERR + = 1, + +198  + #SEGV_MAPERR + +SEGV_MAPERR + + + ) + +199 + mSEGV_ACCERR + + +200  + #SEGV_ACCERR + +SEGV_ACCERR + + + ) + +206 + mBUS_ADRALN + = 1, + +207  + #BUS_ADRALN + +BUS_ADRALN + + + ) + +208 + mBUS_ADRERR +, + +209  + #BUS_ADRERR + +BUS_ADRERR + + + ) + +210 + mBUS_OBJERR + + +211  + #BUS_OBJERR + +BUS_OBJERR + + + ) + +217 + mTRAP_BRKPT + = 1, + +218  + #TRAP_BRKPT + +TRAP_BRKPT + + + ) + +219 + mTRAP_TRACE + + +220  + #TRAP_TRACE + +TRAP_TRACE + + + ) + +226 + mCLD_EXITED + = 1, + +227  + #CLD_EXITED + +CLD_EXITED + + + ) + +228 + mCLD_KILLED +, + +229  + #CLD_KILLED + +CLD_KILLED + + + ) + +230 + mCLD_DUMPED +, + +231  + #CLD_DUMPED + +CLD_DUMPED + + + ) + +232 + mCLD_TRAPPED +, + +233  + #CLD_TRAPPED + +CLD_TRAPPED + + + ) + +234 + mCLD_STOPPED +, + +235  + #CLD_STOPPED + +CLD_STOPPED + + + ) + +236 + mCLD_CONTINUED + + +237  + #CLD_CONTINUED + +CLD_CONTINUED + + + ) + +243 + mPOLL_IN + = 1, + +244  + #POLL_IN + +POLL_IN + + + ) + +245 + mPOLL_OUT +, + +246  + #POLL_OUT + +POLL_OUT + + + ) + +247 + mPOLL_MSG +, + +248  + #POLL_MSG + +POLL_MSG + + + ) + +249 + mPOLL_ERR +, + +250  + #POLL_ERR + +POLL_ERR + + + ) + +251 + mPOLL_PRI +, + +252  + #POLL_PRI + +POLL_PRI + + + ) + +253 + mPOLL_HUP + + +254  + #POLL_HUP + +POLL_HUP + + + ) + +257 #unde +__ed_sigfo_t + + +261 #i( +defed + +_SIGNAL_H + || defed +__ed_sigevt_t +) \ + +262 && ! +defed + + g__have_sigevt_t + + +263  + #__have_sigevt_t + 1 + + ) + +266  + #__SIGEV_MAX_SIZE + 64 + + ) + +267 #i +__WORDSIZE + == 64 + +268  + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + /  ()- 4) + + ) + +270  + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + /  ()- 3) + + ) + +273  + ssigevt + + +275 +sigv_t + + msigev_vue +; + +276  + msigev_signo +; + +277  + msigev_nify +; + +281  + m_d +[ +__SIGEV_PAD_SIZE +]; + +285 +__pid_t + + m_tid +; + +289 (* + m_funi +( + msigv_t +); + +290 * + m_ibu +; + +291 } + m_sigev_thad +; + +292 } + m_sigev_un +; + +293 } + tsigevt_t +; + +296  + #sigev_nify_funi + +_sigev_un +. +_sigev_thad +. +_funi + + + ) + +297  + #sigev_nify_ibus + +_sigev_un +. +_sigev_thad +. +_ibu + + + ) + +302 + mSIGEV_SIGNAL + = 0, + +303  + #SIGEV_SIGNAL + +SIGEV_SIGNAL + + + ) + +304 + mSIGEV_NONE +, + +305  + #SIGEV_NONE + +SIGEV_NONE + + + ) + +306 + mSIGEV_THREAD +, + +307  + #SIGEV_THREAD + +SIGEV_THREAD + + + ) + +309 + mSIGEV_THREAD_ID + = 4 + +310  + #SIGEV_THREAD_ID + +SIGEV_THREAD_ID + + + ) + + @/usr/include/bits/signum.h + +20 #ifdef +_SIGNAL_H + + +23  + #SIG_ERR + (( +__sighdr_t +-1 + + ) + +24  + #SIG_DFL + (( +__sighdr_t +0 + + ) + +25  + #SIG_IGN + (( +__sighdr_t +1 + + ) + +27 #ifde +__USE_UNIX98 + + +28  + #SIG_HOLD + (( +__sighdr_t +2 + + ) + +33  + #SIGHUP + 1 + + ) + +34  + #SIGINT + 2 + + ) + +35  + #SIGQUIT + 3 + + ) + +36  + #SIGILL + 4 + + ) + +37  + #SIGTRAP + 5 + + ) + +38  + #SIGABRT + 6 + + ) + +39  + #SIGIOT + 6 + + ) + +40  + #SIGBUS + 7 + + ) + +41  + #SIGFPE + 8 + + ) + +42  + #SIGKILL + 9 + + ) + +43  + #SIGUSR1 + 10 + + ) + +44  + #SIGSEGV + 11 + + ) + +45  + #SIGUSR2 + 12 + + ) + +46  + #SIGPIPE + 13 + + ) + +47  + #SIGALRM + 14 + + ) + +48  + #SIGTERM + 15 + + ) + +49  + #SIGSTKFLT + 16 + + ) + +50  + #SIGCLD + +SIGCHLD + + + ) + +51  + #SIGCHLD + 17 + + ) + +52  + #SIGCONT + 18 + + ) + +53  + #SIGSTOP + 19 + + ) + +54  + #SIGTSTP + 20 + + ) + +55  + #SIGTTIN + 21 + + ) + +56  + #SIGTTOU + 22 + + ) + +57  + #SIGURG + 23 + + ) + +58  + #SIGXCPU + 24 + + ) + +59  + #SIGXFSZ + 25 + + ) + +60  + #SIGVTALRM + 26 + + ) + +61  + #SIGPROF + 27 + + ) + +62  + #SIGWINCH + 28 + + ) + +63  + #SIGPOLL + +SIGIO + + + ) + +64  + #SIGIO + 29 + + ) + +65  + #SIGPWR + 30 + + ) + +66  + #SIGSYS + 31 + + ) + +67  + #SIGUNUSED + 31 + + ) + +69  + #_NSIG + 65 + + ) + +72  + #SIGRTMIN + ( + `__libc_cut_sigm + ()) + + ) + +73  + #SIGRTMAX + ( + `__libc_cut_sigmax + ()) + + ) + +77  + #__SIGRTMIN + 32 + + ) + +78  + #__SIGRTMAX + ( +_NSIG + - 1) + + ) + + @/usr/include/bits/sigset.h + +21 #idef +_SIGSET_H_tys + + +22  + #_SIGSET_H_tys + 1 + + ) + +24  + t__sig_omic_t +; + +28  + #_SIGSET_NWORDS + (1024 / (8 *  ())) + + ) + +31  + m__v +[ +_SIGSET_NWORDS +]; + +32 } + t__sigt_t +; + +43 #i! +defed + +_SIGSET_H_s + && defed +_SIGNAL_H + + +44  + #_SIGSET_H_s + 1 + + ) + +46 #ide +_EXTERN_INLINE + + +47  + #_EXTERN_INLINE + +__ex_le + + + ) + +51  + #__sigmask +( +sig +) \ + +52 (((1<< ((( +sig +- 1% (8 *  ()))) + + ) + +55  + #__sigwd +( +sig +(((sig- 1/ (8 *  ())) + + ) + +57 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +58  + #__sigemyt +( +t +) \ + +59 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +60 +sigt_t + * +__t + = ( +t +); \ + +61 -- +__t + >0 +__t +-> +__v +[__cnt] = 0; \ + +62 0; })) + + ) + +63  + #__sigflt +( +t +) \ + +64 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +65 +sigt_t + * +__t + = ( +t +); \ + +66 -- +__t + >0 +__t +-> +__v +[__cnt] = ~0UL; \ + +67 0; })) + + ) + +69 #ifde +__USE_GNU + + +73  + #__sigimyt +( +t +) \ + +74 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +75 cڡ +sigt_t + * +__t + = ( +t +); \ + +76  +__t + = +__t +-> +__v +[-- +__t +]; \ + +77 ! +__t + && -- +__t + >= 0) \ + +78 +__t + = +__t +-> +__v +[ +__t +]; \ + +79 +__t + =0; })) + + ) + +80  + #__sigdt +( +de +, + +, +right +) \ + +81 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +82 +sigt_t + * +__de + = ( +de +); \ + +83 cڡ +sigt_t + * +__ + = ( + +); \ + +84 cڡ +sigt_t + * +__right + = ( +right +); \ + +85 -- +__t + >= 0) \ + +86 +__de +-> +__v +[ +__t +] = ( +__ +->__val[__cnt] \ + +87 & +__right +-> +__v +[ +__t +]); \ + +88 0; })) + + ) + +89  + #__sigܣt +( +de +, + +, +right +) \ + +90 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +91 +sigt_t + * +__de + = ( +de +); \ + +92 cڡ +sigt_t + * +__ + = ( + +); \ + +93 cڡ +sigt_t + * +__right + = ( +right +); \ + +94 -- +__t + >= 0) \ + +95 +__de +-> +__v +[ +__t +] = ( +__ +->__val[__cnt] \ + +96 | +__right +-> +__v +[ +__t +]); \ + +97 0; })) + + ) + +104  +__sigismemb + ( +__cڡ + +__sigt_t + *, ); + +105  +__sigaddt + ( +__sigt_t + *, ); + +106  +__sigdt + ( +__sigt_t + *, ); + +108 #ifde +__USE_EXTERN_INLINES + + +109  + #__SIGSETFN +( +NAME +, +BODY +, +CONST +) \ + +110 +_EXTERN_INLINE + \ + +111 + `NAME + ( +CONST + +__sigt_t + * +__t +,  +__sig +) \ + +113  +__mask + = + `__sigmask + ( +__sig +); \ + +114  +__wd + = + `__sigwd + ( +__sig +); \ + +115  +BODY +; \ + +116 } + + ) + +118 +__SIGSETFN + ( +__sigismemb +, ( +__t +-> +__v +[ +__wd +] & +__mask +? 1 : 0, +__cڡ +) + +119 +__SIGSETFN + ( +__sigaddt +, (( +__t +-> +__v +[ +__wd +] | +__mask +), 0), ) + +120 +__SIGSETFN + ( +__sigdt +, (( +__t +-> +__v +[ +__wd +] &~ +__mask +), 0), ) + +122 #unde +__SIGSETFN + + + @/usr/include/bits/sigstack.h + +20 #ide +_SIGNAL_H + + +26  + ssigack + + +28 * + mss_ +; + +29  + mss_ڡack +; + +36 + mSS_ONSTACK + = 1, + +37  + #SS_ONSTACK + +SS_ONSTACK + + + ) + +38 + mSS_DISABLE + + +39  + #SS_DISABLE + +SS_DISABLE + + + ) + +43  + #MINSIGSTKSZ + 2048 + + ) + +46  + #SIGSTKSZ + 8192 + + ) + +50  + ssigtack + + +52 * + mss_ +; + +53  + mss_ags +; + +54 +size_t + + mss_size +; + +55 } + tack_t +; + + @/usr/include/bits/sigthread.h + +20 #ide +_BITS_SIGTHREAD_H + + +21  + #_BITS_SIGTHREAD_H + 1 + + ) + +23 #i! +defed + +_SIGNAL_H + && !defed +_PTHREAD_H + + +31  + $had_sigmask + ( +__how +, + +32 +__cڡ + +__sigt_t + * +__ri + +__wmask +, + +33 +__sigt_t + * +__ri + +__dmask +) +__THROW +; + +36  + $had_kl + ( +had_t + +__thadid +,  +__signo + +__THROW +; + +38 #ifde +__USE_GNU + + +40  + $had_sigqueue + ( +had_t + +__thadid +,  +__signo +, + +41 cڡ  +sigv + +__vue + +__THROW +; + + @/usr/include/bits/time.h + +24 #ide +__ed_timev + + +25 #ide +_BITS_TIME_H + + +26  + #_BITS_TIME_H + 1 + + ) + +34  + #CLOCKS_PER_SEC + 1000000l + + ) + +36 #i! +defed + +__STRICT_ANSI__ + && !defed +__USE_XOPEN2K + + +39  + ~ + +40  +__syscf + (); + +41  + #CLK_TCK + (( +__ock_t + + `__syscf + (2) + + ) + +44 #ifde +__USE_POSIX199309 + + +46  + #CLOCK_REALTIME + 0 + + ) + +48  + #CLOCK_MONOTONIC + 1 + + ) + +50  + #CLOCK_PROCESS_CPUTIME_ID + 2 + + ) + +52  + #CLOCK_THREAD_CPUTIME_ID + 3 + + ) + +55  + #TIMER_ABSTIME + 1 + + ) + +61 #ifde +__ed_timev + + +62 #unde +__ed_timev + + +63 #ide +_STRUCT_TIMEVAL + + +64  + #_STRUCT_TIMEVAL + 1 + + ) + +65  + ~ + +69  + stimev + + +71 +__time_t + + mtv_c +; + +72 +__sucds_t + + mtv_uc +; + + @/usr/include/linux/errno.h + +1 #ide +_LINUX_ERRNO_H + + +2  + #_LINUX_ERRNO_H + + + ) + +4  + ~ + + @/usr/include/sys/ucontext.h + +19 #ide +_SYS_UCONTEXT_H + + +20  + #_SYS_UCONTEXT_H + 1 + + ) + +22  + ~ + +23  + ~ + +24  + ~ + +28  + ~ + +30 #i +__WORDSIZE + == 64 + +33  + tgg_t +; + +36  + #NGREG + 23 + + ) + +39  +gg_t + + tggt_t +[ +NGREG +]; + +41 #ifde +__USE_GNU + + +45 + mREG_R8 + = 0, + +46  + #REG_R8 + +REG_R8 + + + ) + +47 + mREG_R9 +, + +48  + #REG_R9 + +REG_R9 + + + ) + +49 + mREG_R10 +, + +50  + #REG_R10 + +REG_R10 + + + ) + +51 + mREG_R11 +, + +52  + #REG_R11 + +REG_R11 + + + ) + +53 + mREG_R12 +, + +54  + #REG_R12 + +REG_R12 + + + ) + +55 + mREG_R13 +, + +56  + #REG_R13 + +REG_R13 + + + ) + +57 + mREG_R14 +, + +58  + #REG_R14 + +REG_R14 + + + ) + +59 + mREG_R15 +, + +60  + #REG_R15 + +REG_R15 + + + ) + +61 + mREG_RDI +, + +62  + #REG_RDI + +REG_RDI + + + ) + +63 + mREG_RSI +, + +64  + #REG_RSI + +REG_RSI + + + ) + +65 + mREG_RBP +, + +66  + #REG_RBP + +REG_RBP + + + ) + +67 + mREG_RBX +, + +68  + #REG_RBX + +REG_RBX + + + ) + +69 + mREG_RDX +, + +70  + #REG_RDX + +REG_RDX + + + ) + +71 + mREG_RAX +, + +72  + #REG_RAX + +REG_RAX + + + ) + +73 + mREG_RCX +, + +74  + #REG_RCX + +REG_RCX + + + ) + +75 + mREG_RSP +, + +76  + #REG_RSP + +REG_RSP + + + ) + +77 + mREG_RIP +, + +78  + #REG_RIP + +REG_RIP + + + ) + +79 + mREG_EFL +, + +80  + #REG_EFL + +REG_EFL + + + ) + +81 + mREG_CSGSFS +, + +82  + #REG_CSGSFS + +REG_CSGSFS + + + ) + +83 + mREG_ERR +, + +84  + #REG_ERR + +REG_ERR + + + ) + +85 + mREG_TRAPNO +, + +86  + #REG_TRAPNO + +REG_TRAPNO + + + ) + +87 + mREG_OLDMASK +, + +88  + #REG_OLDMASK + +REG_OLDMASK + + + ) + +89 + mREG_CR2 + + +90  + #REG_CR2 + +REG_CR2 + + + ) + +94  + s_libc_xg + + +96  + msignifind +[4]; + +97  + mexpڒt +; + +98  + mddg +[3]; + +101  + s_libc_xmmg + + +103 +__ut32_t + + memt +[4]; + +106  + s_libc_塩e + + +109 +__ut16_t + + mcwd +; + +110 +__ut16_t + + mswd +; + +111 +__ut16_t + + mw +; + +112 +__ut16_t + + mf +; + +113 +__ut64_t + + mr +; + +114 +__ut64_t + + mrdp +; + +115 +__ut32_t + + mmxc +; + +116 +__ut32_t + + mmx_mask +; + +117  +_libc_xg + + m_ +[8]; + +118  +_libc_xmmg + + m_xmm +[16]; + +119 +__ut32_t + + mddg +[24]; + +123  +_libc_塩e + * + tgt_t +; + +128 +ggt_t + + mggs +; + +130 +gt_t + + mgs +; + +131  + m__rved1 + [8]; + +132 } + tmcڋxt_t +; + +135  + sucڋxt + + +137  + muc_ags +; + +138  +ucڋxt + * + muc_lk +; + +139 +ack_t + + muc_ack +; + +140 +mcڋxt_t + + muc_mcڋxt +; + +141 +__sigt_t + + muc_sigmask +; + +142  +_libc_塩e + + m__gs_mem +; + +143 } + tucڋxt_t +; + +148  + tgg_t +; + +151  + #NGREG + 19 + + ) + +154  +gg_t + + tggt_t +[ +NGREG +]; + +156 #ifde +__USE_GNU + + +160 + mREG_GS + = 0, + +161  + #REG_GS + +REG_GS + + + ) + +162 + mREG_FS +, + +163  + #REG_FS + +REG_FS + + + ) + +164 + mREG_ES +, + +165  + #REG_ES + +REG_ES + + + ) + +166 + mREG_DS +, + +167  + #REG_DS + +REG_DS + + + ) + +168 + mREG_EDI +, + +169  + #REG_EDI + +REG_EDI + + + ) + +170 + mREG_ESI +, + +171  + #REG_ESI + +REG_ESI + + + ) + +172 + mREG_EBP +, + +173  + #REG_EBP + +REG_EBP + + + ) + +174 + mREG_ESP +, + +175  + #REG_ESP + +REG_ESP + + + ) + +176 + mREG_EBX +, + +177  + #REG_EBX + +REG_EBX + + + ) + +178 + mREG_EDX +, + +179  + #REG_EDX + +REG_EDX + + + ) + +180 + mREG_ECX +, + +181  + #REG_ECX + +REG_ECX + + + ) + +182 + mREG_EAX +, + +183  + #REG_EAX + +REG_EAX + + + ) + +184 + mREG_TRAPNO +, + +185  + #REG_TRAPNO + +REG_TRAPNO + + + ) + +186 + mREG_ERR +, + +187  + #REG_ERR + +REG_ERR + + + ) + +188 + mREG_EIP +, + +189  + #REG_EIP + +REG_EIP + + + ) + +190 + mREG_CS +, + +191  + #REG_CS + +REG_CS + + + ) + +192 + mREG_EFL +, + +193  + #REG_EFL + +REG_EFL + + + ) + +194 + mREG_UESP +, + +195  + #REG_UESP + +REG_UESP + + + ) + +196 + mREG_SS + + +197  + #REG_SS + +REG_SS + + + ) + +202  + s_libc_g + + +204  + msignifind +[4]; + +205  + mexpڒt +; + +208  + s_libc_塩e + + +210  + mcw +; + +211  + msw +; + +212  + mg +; + +213  + moff +; + +214  + mcsl +; + +215  + mdaoff +; + +216  + mdal +; + +217  +_libc_g + + m_ +[8]; + +218  + mus +; + +222  +_libc_塩e + * + tgt_t +; + +227 +ggt_t + + mggs +; + +230 +gt_t + + mgs +; + +231  + mdmask +; + +232  + m2 +; + +233 } + tmcڋxt_t +; + +236  + sucڋxt + + +238  + muc_ags +; + +239  +ucڋxt + * + muc_lk +; + +240 +ack_t + + muc_ack +; + +241 +mcڋxt_t + + muc_mcڋxt +; + +242 +__sigt_t + + muc_sigmask +; + +243  +_libc_塩e + + m__gs_mem +; + +244 } + tucڋxt_t +; + + @/usr/include/asm/errno.h + +1  + ~ + + @/usr/include/asm-generic/errno.h + +1 #ide +_ASM_GENERIC_ERRNO_H + + +2  + #_ASM_GENERIC_ERRNO_H + + + ) + +4  + ~ + +6  + #EDEADLK + 35 + + ) + +7  + #ENAMETOOLONG + 36 + + ) + +8  + #ENOLCK + 37 + + ) + +9  + #ENOSYS + 38 + + ) + +10  + #ENOTEMPTY + 39 + + ) + +11  + #ELOOP + 40 + + ) + +12  + #EWOULDBLOCK + +EAGAIN + + + ) + +13  + #ENOMSG + 42 + + ) + +14  + #EIDRM + 43 + + ) + +15  + #ECHRNG + 44 + + ) + +16  + #EL2NSYNC + 45 + + ) + +17  + #EL3HLT + 46 + + ) + +18  + #EL3RST + 47 + + ) + +19  + #ELNRNG + 48 + + ) + +20  + #EUNATCH + 49 + + ) + +21  + #ENOCSI + 50 + + ) + +22  + #EL2HLT + 51 + + ) + +23  + #EBADE + 52 + + ) + +24  + #EBADR + 53 + + ) + +25  + #EXFULL + 54 + + ) + +26  + #ENOANO + 55 + + ) + +27  + #EBADRQC + 56 + + ) + +28  + #EBADSLT + 57 + + ) + +30  + #EDEADLOCK + +EDEADLK + + + ) + +32  + #EBFONT + 59 + + ) + +33  + #ENOSTR + 60 + + ) + +34  + #ENODATA + 61 + + ) + +35  + #ETIME + 62 + + ) + +36  + #ENOSR + 63 + + ) + +37  + #ENONET + 64 + + ) + +38  + #ENOPKG + 65 + + ) + +39  + #EREMOTE + 66 + + ) + +40  + #ENOLINK + 67 + + ) + +41  + #EADV + 68 + + ) + +42  + #ESRMNT + 69 + + ) + +43  + #ECOMM + 70 + + ) + +44  + #EPROTO + 71 + + ) + +45  + #EMULTIHOP + 72 + + ) + +46  + #EDOTDOT + 73 + + ) + +47  + #EBADMSG + 74 + + ) + +48  + #EOVERFLOW + 75 + + ) + +49  + #ENOTUNIQ + 76 + + ) + +50  + #EBADFD + 77 + + ) + +51  + #EREMCHG + 78 + + ) + +52  + #ELIBACC + 79 + + ) + +53  + #ELIBBAD + 80 + + ) + +54  + #ELIBSCN + 81 + + ) + +55  + #ELIBMAX + 82 + + ) + +56  + #ELIBEXEC + 83 + + ) + +57  + #EILSEQ + 84 + + ) + +58  + #ERESTART + 85 + + ) + +59  + #ESTRPIPE + 86 + + ) + +60  + #EUSERS + 87 + + ) + +61  + #ENOTSOCK + 88 + + ) + +62  + #EDESTADDRREQ + 89 + + ) + +63  + #EMSGSIZE + 90 + + ) + +64  + #EPROTOTYPE + 91 + + ) + +65  + #ENOPROTOOPT + 92 + + ) + +66  + #EPROTONOSUPPORT + 93 + + ) + +67  + #ESOCKTNOSUPPORT + 94 + + ) + +68  + #EOPNOTSUPP + 95 + + ) + +69  + #EPFNOSUPPORT + 96 + + ) + +70  + #EAFNOSUPPORT + 97 + + ) + +71  + #EADDRINUSE + 98 + + ) + +72  + #EADDRNOTAVAIL + 99 + + ) + +73  + #ENETDOWN + 100 + + ) + +74  + #ENETUNREACH + 101 + + ) + +75  + #ENETRESET + 102 + + ) + +76  + #ECONNABORTED + 103 + + ) + +77  + #ECONNRESET + 104 + + ) + +78  + #ENOBUFS + 105 + + ) + +79  + #EISCONN + 106 + + ) + +80  + #ENOTCONN + 107 + + ) + +81  + #ESHUTDOWN + 108 + + ) + +82  + #ETOOMANYREFS + 109 + + ) + +83  + #ETIMEDOUT + 110 + + ) + +84  + #ECONNREFUSED + 111 + + ) + +85  + #EHOSTDOWN + 112 + + ) + +86  + #EHOSTUNREACH + 113 + + ) + +87  + #EALREADY + 114 + + ) + +88  + #EINPROGRESS + 115 + + ) + +89  + #ESTALE + 116 + + ) + +90  + #EUCLEAN + 117 + + ) + +91  + #ENOTNAM + 118 + + ) + +92  + #ENAVAIL + 119 + + ) + +93  + #EISNAM + 120 + + ) + +94  + #EREMOTEIO + 121 + + ) + +95  + #EDQUOT + 122 + + ) + +97  + #ENOMEDIUM + 123 + + ) + +98  + #EMEDIUMTYPE + 124 + + ) + +99  + #ECANCELED + 125 + + ) + +100  + #ENOKEY + 126 + + ) + +101  + #EKEYEXPIRED + 127 + + ) + +102  + #EKEYREVOKED + 128 + + ) + +103  + #EKEYREJECTED + 129 + + ) + +106  + #EOWNERDEAD + 130 + + ) + +107  + #ENOTRECOVERABLE + 131 + + ) + +109  + #ERFKILL + 132 + + ) + + @/usr/include/asm-generic/errno-base.h + +1 #ide +_ASM_GENERIC_ERRNO_BASE_H + + +2  + #_ASM_GENERIC_ERRNO_BASE_H + + + ) + +4  + #EPERM + 1 + + ) + +5  + #ENOENT + 2 + + ) + +6  + #ESRCH + 3 + + ) + +7  + #EINTR + 4 + + ) + +8  + #EIO + 5 + + ) + +9  + #ENXIO + 6 + + ) + +10  + #E2BIG + 7 + + ) + +11  + #ENOEXEC + 8 + + ) + +12  + #EBADF + 9 + + ) + +13  + #ECHILD + 10 + + ) + +14  + #EAGAIN + 11 + + ) + +15  + #ENOMEM + 12 + + ) + +16  + #EACCES + 13 + + ) + +17  + #EFAULT + 14 + + ) + +18  + #ENOTBLK + 15 + + ) + +19  + #EBUSY + 16 + + ) + +20  + #EEXIST + 17 + + ) + +21  + #EXDEV + 18 + + ) + +22  + #ENODEV + 19 + + ) + +23  + #ENOTDIR + 20 + + ) + +24  + #EISDIR + 21 + + ) + +25  + #EINVAL + 22 + + ) + +26  + #ENFILE + 23 + + ) + +27  + #EMFILE + 24 + + ) + +28  + #ENOTTY + 25 + + ) + +29  + #ETXTBSY + 26 + + ) + +30  + #EFBIG + 27 + + ) + +31  + #ENOSPC + 28 + + ) + +32  + #ESPIPE + 29 + + ) + +33  + #EROFS + 30 + + ) + +34  + #EMLINK + 31 + + ) + +35  + #EPIPE + 32 + + ) + +36  + #EDOM + 33 + + ) + +37  + #ERANGE + 34 + + ) + + @ +1 +. +1 +/usr/include +64 +1601 +CG.h +CG_outputBuilder.h +CG_outputRepr.h +CG_stringBuilder.h +CG_stringRepr.h +CG_suifBuilder.h +CG_suifRepr.h +code_gen.h +output_repr.h +/usr/include/stdio.h +/usr/include/bits/stdio-ldbl.h +/usr/include/bits/stdio.h +/usr/include/bits/stdio2.h +/usr/include/bits/stdio_lim.h +/usr/include/bits/sys_errlist.h +/usr/include/bits/types.h +/usr/include/features.h +/usr/include/getopt.h +/usr/include/libio.h +/usr/include/_G_config.h +/usr/include/bits/libio-ldbl.h +/usr/include/bits/predefs.h +/usr/include/bits/stdio-lock.h +/usr/include/bits/typesizes.h +/usr/include/bits/wordsize.h +/usr/include/ctype.h +/usr/include/gnu/stubs.h +/usr/include/sys/cdefs.h +/usr/include/bits/libc-lock.h +/usr/include/endian.h +/usr/include/gconv.h +/usr/include/gnu/stubs-32.h +/usr/include/gnu/stubs-64.h +/usr/include/wchar.h +/usr/include/xlocale.h +/usr/include/bits/byteswap.h +/usr/include/bits/endian.h +/usr/include/bits/wchar-ldbl.h +/usr/include/bits/wchar.h +/usr/include/bits/wchar2.h +/usr/include/errno.h +/usr/include/gnu/option-groups.h +/usr/include/pthread.h +/usr/include/wctype.h +/usr/include/bits/errno.h +/usr/include/bits/pthreadtypes.h +/usr/include/bits/setjmp.h +/usr/include/sched.h +/usr/include/signal.h +/usr/include/time.h +/usr/include/bits/sched.h +/usr/include/bits/sigaction.h +/usr/include/bits/sigcontext.h +/usr/include/bits/siginfo.h +/usr/include/bits/signum.h +/usr/include/bits/sigset.h +/usr/include/bits/sigstack.h +/usr/include/bits/sigthread.h +/usr/include/bits/time.h +/usr/include/linux/errno.h +/usr/include/sys/ucontext.h +/usr/include/asm/errno.h +/usr/include/asm-generic/errno.h +/usr/include/asm-generic/errno-base.h diff --git a/omega/code_gen/include/code_gen/output_repr.h b/omega/code_gen/include/code_gen/output_repr.h new file mode 100644 index 0000000..254e71b --- /dev/null +++ b/omega/code_gen/include/code_gen/output_repr.h @@ -0,0 +1,46 @@ +#ifndef OUTPUT_REPR_H +#define OUTPUT_REPR_H + +#include +#include +#include +#include +#include + +namespace omega { +extern int last_level; + +CG_outputRepr* outputIdent(CG_outputBuilder* ocg, const Relation &R, Variable_ID v, const std::vector &assigned_on_the_fly); +std::pair outputAssignment(CG_outputBuilder *ocg, const Relation &R_, Variable_ID v, Relation &enforced, CG_outputRepr *&if_repr, const std::vector &assigned_on_the_fly); +std::pair outputBounds(CG_outputBuilder* ocg, const Relation &bounds, Variable_ID v, int indent, Relation &enforced, const std::vector &assigned_on_the_fly); +Tuple outputSubstitution(CG_outputBuilder* ocg, const Relation &R, const std::vector &assigned_on_the_fly); +CG_outputRepr* outputStatement(CG_outputBuilder* ocg, CG_outputRepr *stmt, int indent, const Relation &mapping, const Relation &known, const std::vector &assigned_on_the_fly); +CG_outputRepr* outputGuard(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly); +CG_outputRepr* output_as_guard(CG_outputBuilder* ocg, const Relation &guards_in, Constraint_Handle e, bool is_equality, const std::vector &assigned_on_the_fly); +CG_outputRepr* output_EQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly); +CG_outputRepr* output_GEQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly); +CG_outputRepr *outputLBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, Relation &bounds, Variable_ID v, coef_t stride, const EQ_Handle &strideEQ, Relation known, const std::vector &assigned_on_the_fly); +CG_outputRepr *outputUBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, Relation & bounds, Variable_ID v, + coef_t /*stride*/, // currently unused + const EQ_Handle &/*strideEQ*/, + const std::vector &assigned_on_the_fly = std::vector(last_level, static_cast(NULL))); +CG_outputRepr* outputEasyBoundAsRepr(CG_outputBuilder* ocg, Relation &bounds, const Constraint_Handle &g, Variable_ID v, bool ignoreWC, int ceiling, const std::vector &assigned_on_the_fly); + + +bool boundHitsStride(const GEQ_Handle &g, Variable_ID v, const EQ_Handle &strideEQ, coef_t /*stride, currently unused*/, Relation known); +Relation greatest_common_step(const Tuple &I, const Tuple &active, int level, const Relation &known = Relation::Null()); +bool findFloorInequality(Relation &r, Variable_ID v, GEQ_Handle &h, Variable_ID excluded); +Relation project_onto_levels(Relation R, int last_level, bool wildcards); +bool isSimpleStride(const EQ_Handle &g, Variable_ID v); +int countStrides(Conjunct *c, Variable_ID v, EQ_Handle &strideEQ, bool &simple); +bool hasBound(Relation r, int level, int UB); +bool find_any_constraint(int s, int level, Relation &kr, int direction, Relation &S, bool approx); +bool has_nonstride_EQ(Relation r, int level); +Relation pickOverhead(Relation r, int liftTo); +Relation minMaxOverhead(Relation r, int level); +int max_fs_arity(const Constraint_Handle &c); + + +} + +#endif diff --git a/omega/code_gen/include/code_gen/rose_attributes.h b/omega/code_gen/include/code_gen/rose_attributes.h new file mode 100644 index 0000000..9766f52 --- /dev/null +++ b/omega/code_gen/include/code_gen/rose_attributes.h @@ -0,0 +1,91 @@ +#ifndef ROSE_ATTRIBUTES_HH +#define ROSE_ATTRIBUTES_HH + +#include "rose.h" +#include +#include +#include + +namespace omega { + +class CodeInsertion; + +typedef std::vector CodeInsertionPtrList; +typedef std::vector::iterator CodeInsertionPtrListItr; + +class CodeInsertion { +public: + int loop_level; + bool marked; + CodeInsertion(int looplevel) { this->loop_level = looplevel; marked = false; } + ~CodeInsertion() {} + virtual SgStatement* getStatement(SgScopeStatement* scopeStmt = NULL) = 0; +}; + +class PragmaInsertion : public CodeInsertion { +private: + std::string name; +public: + PragmaInsertion(int loop_level, const std::string &pragma) : CodeInsertion(loop_level) { this->name = std::string(pragma); } + ~PragmaInsertion() { } + virtual SgStatement* getStatement(SgScopeStatement* scopeStmt = NULL); +}; + +class MMPrefetchInsertion : public CodeInsertion { +private: + std::string arrName; + std::vector indecies; + std::vector offsets; + int indexCount; + int cacheHint; + void initialize(const std::string& arrName, int hint); + void addDim(int offset); + void addDim(int offset, const std::string& indexer); + SgExpression* buildArrArg(SgScopeStatement* scopeStmt); + SgExpression* makeIndexExp(int dim, SgScopeStatement* scopeStmt); +public: + MMPrefetchInsertion(int loop_level, const std::string &arr, int hint) : CodeInsertion(loop_level) + { this->initialize(arr, hint); } + ~MMPrefetchInsertion() { } + virtual SgStatement* getStatement(SgScopeStatement* scopeStmt = NULL); +}; + +class CodeInsertionAttribute : public AstAttribute { +private: + std::vector code_insertions; +public: + CodeInsertionAttribute() { code_insertions = std::vector(); } + ~CodeInsertionAttribute() {} + + void add(CodeInsertion* ci) { code_insertions.push_back(ci); } + CodeInsertionPtrListItr begin() { return code_insertions.begin(); } + CodeInsertionPtrListItr end() { return code_insertions.end(); } + void remove(CodeInsertion* ci) { std::remove(code_insertions.begin(), code_insertions.end(), ci); } + int countCodeInsertions() { return code_insertions.size(); } +}; + +struct CodeInsertionMark { +public: + SgStatement* stmt; + CodeInsertion* ci; +}; + +class CodeInsertionVisitor : public AstPrePostProcessing { +private: + int loop_level; + std::vector ci_marks; + void markStmt(SgStatement* stmt, CodeInsertion* ci); +public: + void initialize(); + virtual void preOrderVisit(SgNode* n); + virtual void postOrderVisit(SgNode* n); + void insertCode(); +}; + +void postProcessRoseCodeInsertion(SgProject* proj); +void copyAttributes(SgNode* s, SgNode* d); +CodeInsertionAttribute* getOrCreateCodeInsertionAttribute(SgNode* node); + +} + +#endif diff --git a/omega/code_gen/obj/Makefile b/omega/code_gen/obj/Makefile new file mode 100644 index 0000000..dbc65fe --- /dev/null +++ b/omega/code_gen/obj/Makefile @@ -0,0 +1,49 @@ + +# DON'T EDIT -- put any locally required changes in Makefile.config. + + +LIB_TARGET=libcodegen.a + +all: $(LIB_TARGET) +depend: depend_self +clean: clean_self +veryclean: veryclean_self + +BASIC_SRC = ../src/codegen.cc ../src/CG_stringBuilder.cc ../src/CG.cc ../src/CG_utils.cc +BASIC_OBJ = $(BASIC_SRC:../src/%.cc=%.o) + + +ROSE_SRC = ../src/rose_attributes.cc ../src/CG_roseRepr.cc ../src/CG_roseBuilder.cc +ROSE_OBJ = $(ROSE_SRC:../src/%.cc=%.o) + +OBJS = ${BASIC_OBJ} +SRCS = ${BASIC_SRC} + +BASEDIR=../.. +include $(BASEDIR)/Makefile.config + +INCL_PATH := $(INCL_PATH) -I../../omega_lib/include + + + + +ifeq ($(BUILD_ROSE), true) +OBJS := $(OBJS) $(ROSE_OBJ) +SRCS := $(SRCS) $(ROSE_SRC) +INCL_PATH := $(INCL_PATH) -I${ROSEHOME}/include -I${BOOSTHOME}/include +endif + +ifeq ($(BUILD_ROSE), true) +IR_OBJ = $(ROSE_SRC:../src/%.cc=%.o) +endif + +include $(BASEDIR)/Makefile.rules + + +# suppress warning of constant char * conversion nuiance in suif +$(IR_OBJ): %.o: ../src/%.cc + $(CC) -Wno-write-strings $(CFLAGS) $(INCL_PATH) -c $< -o $@ + +ifeq ($(shell test -f Makefile.deps && echo "true"), true) +include Makefile.deps +endif diff --git a/omega/code_gen/obj/Makefile.deps b/omega/code_gen/obj/Makefile.deps new file mode 100644 index 0000000..c420660 --- /dev/null +++ b/omega/code_gen/obj/Makefile.deps @@ -0,0 +1,3934 @@ +codegen.o: ../src/codegen.cc /usr/include/c++/4.4/typeinfo \ + /usr/include/c++/4.4/exception \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/features.h /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + ../../omega_lib/include/omega.h \ + ../../omega_lib/include/omega/omega_core/debugging.h \ + /usr/include/stdio.h /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h \ + /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/libio.h \ + /usr/include/_G_config.h /usr/include/wchar.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h /usr/include/ctype.h \ + /usr/include/endian.h /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h /usr/include/xlocale.h \ + ../../omega_lib/include/omega/pres_var.h \ + ../../omega_lib/include/omega/pres_gen.h \ + ../../omega_lib/include/omega/omega_core/oc.h \ + /usr/include/c++/4.4/string /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/stl_algobase.h /usr/include/c++/4.4/cstddef \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/postypes.h \ + /usr/include/c++/4.4/cwchar /usr/include/i386-linux-gnu/bits/wchar.h \ + /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h /usr/include/time.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/basic_string.tcc \ + ../../basic/include/basic/util.h /usr/include/stdlib.h \ + /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h \ + /usr/include/i386-linux-gnu/sys/types.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h /usr/include/alloca.h \ + /usr/include/assert.h /usr/include/c++/4.4/sstream \ + /usr/include/c++/4.4/istream /usr/include/c++/4.4/ios \ + /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/bits/ostream.tcc \ + /usr/include/c++/4.4/bits/istream.tcc \ + /usr/include/c++/4.4/bits/sstream.tcc /usr/include/c++/4.4/stdexcept \ + ../../basic/include/basic/Tuple.h ../../basic/include/basic/Collection.h \ + ../../basic/include/basic/Iterator.h ../../basic/include/basic/Tuple.c \ + ../../basic/include/basic/ConstString.h ../../basic/include/basic/List.h \ + ../../basic/include/basic/Link.h ../../basic/include/basic/List.c \ + /usr/include/c++/4.4/map /usr/include/c++/4.4/bits/stl_tree.h \ + /usr/include/c++/4.4/bits/stl_map.h \ + /usr/include/c++/4.4/bits/stl_multimap.h \ + ../../omega_lib/include/omega/pres_cnstr.h /usr/include/c++/4.4/vector \ + /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc \ + ../../omega_lib/include/omega/pres_subs.h \ + ../../omega_lib/include/omega/Relation.h \ + ../../omega_lib/include/omega/RelBody.h \ + ../../omega_lib/include/omega/pres_form.h \ + ../../omega_lib/include/omega/pres_dnf.h /usr/include/c++/4.4/iostream \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/limits.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/i386-linux-gnu/bits/posix1_lim.h \ + /usr/include/i386-linux-gnu/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/i386-linux-gnu/bits/posix2_lim.h \ + /usr/include/i386-linux-gnu/bits/xopen_lim.h \ + ../../omega_lib/include/omega/Relations.h \ + ../../omega_lib/include/omega/pres_conj.h \ + ../../omega_lib/include/omega/pres_decl.h \ + ../../basic/include/basic/Section.h ../../basic/include/basic/Section.c \ + ../../omega_lib/include/omega/pres_logic.h \ + ../../omega_lib/include/omega/pres_quant.h \ + ../../omega_lib/include/omega/pres_cmpr.h \ + ../../omega_lib/include/omega/Rel_map.h \ + ../../omega_lib/include/omega/farkas.h \ + ../../omega_lib/include/omega/hull.h \ + ../../omega_lib/include/omega/closure.h /usr/include/math.h \ + /usr/include/i386-linux-gnu/bits/huge_val.h \ + /usr/include/i386-linux-gnu/bits/huge_valf.h \ + /usr/include/i386-linux-gnu/bits/huge_vall.h \ + /usr/include/i386-linux-gnu/bits/inf.h \ + /usr/include/i386-linux-gnu/bits/nan.h \ + /usr/include/i386-linux-gnu/bits/mathdef.h \ + /usr/include/i386-linux-gnu/bits/mathcalls.h \ + /usr/include/c++/4.4/algorithm /usr/include/c++/4.4/bits/stl_algo.h \ + /usr/include/c++/4.4/cstdlib /usr/include/c++/4.4/bits/algorithmfwd.h \ + /usr/include/c++/4.4/bits/stl_heap.h \ + /usr/include/c++/4.4/bits/stl_tempbuf.h ../include/code_gen/CG.h \ + ../../basic/include/basic/boolset.h /usr/include/c++/4.4/iterator \ + /usr/include/c++/4.4/bits/stream_iterator.h \ + ../include/code_gen/CG_outputBuilder.h \ + ../include/code_gen/CG_outputRepr.h ../include/code_gen/codegen.h \ + ../include/code_gen/codegen_error.h +CG_stringBuilder.o: ../src/CG_stringBuilder.cc \ + ../include/code_gen/CG_stringBuilder.h \ + ../include/code_gen/CG_outputBuilder.h \ + ../include/code_gen/CG_outputRepr.h /usr/include/c++/4.4/string \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/features.h /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/stl_algobase.h /usr/include/c++/4.4/cstddef \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/postypes.h \ + /usr/include/c++/4.4/cwchar /usr/include/wchar.h /usr/include/stdio.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/i386-linux-gnu/bits/wchar.h /usr/include/xlocale.h \ + /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/exception /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/ctype.h \ + /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/endian.h \ + /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h \ + /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h /usr/include/time.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/basic_string.tcc /usr/include/c++/4.4/vector \ + /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc ../include/code_gen/CG_stringRepr.h \ + /usr/include/c++/4.4/iostream /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/ios /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc \ + /usr/include/c++/4.4/bits/ostream.tcc /usr/include/c++/4.4/istream \ + /usr/include/c++/4.4/bits/istream.tcc \ + ../include/code_gen/codegen_error.h /usr/include/c++/4.4/stdexcept \ + ../../basic/include/basic/util.h /usr/include/libio.h \ + /usr/include/_G_config.h /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h /usr/include/stdlib.h \ + /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h \ + /usr/include/i386-linux-gnu/sys/types.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h /usr/include/alloca.h \ + /usr/include/assert.h /usr/include/c++/4.4/sstream \ + /usr/include/c++/4.4/bits/sstream.tcc /usr/include/string.h +CG.o: ../src/CG.cc /usr/include/c++/4.4/typeinfo \ + /usr/include/c++/4.4/exception \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/features.h /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + /usr/include/assert.h ../../omega_lib/include/omega.h \ + ../../omega_lib/include/omega/omega_core/debugging.h \ + /usr/include/stdio.h /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h \ + /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/libio.h \ + /usr/include/_G_config.h /usr/include/wchar.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h /usr/include/ctype.h \ + /usr/include/endian.h /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h /usr/include/xlocale.h \ + ../../omega_lib/include/omega/pres_var.h \ + ../../omega_lib/include/omega/pres_gen.h \ + ../../omega_lib/include/omega/omega_core/oc.h \ + /usr/include/c++/4.4/string /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/stl_algobase.h /usr/include/c++/4.4/cstddef \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/postypes.h \ + /usr/include/c++/4.4/cwchar /usr/include/i386-linux-gnu/bits/wchar.h \ + /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h /usr/include/time.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/basic_string.tcc \ + ../../basic/include/basic/util.h /usr/include/stdlib.h \ + /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h \ + /usr/include/i386-linux-gnu/sys/types.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h /usr/include/alloca.h \ + /usr/include/c++/4.4/sstream /usr/include/c++/4.4/istream \ + /usr/include/c++/4.4/ios /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/bits/ostream.tcc \ + /usr/include/c++/4.4/bits/istream.tcc \ + /usr/include/c++/4.4/bits/sstream.tcc /usr/include/c++/4.4/stdexcept \ + ../../basic/include/basic/Tuple.h ../../basic/include/basic/Collection.h \ + ../../basic/include/basic/Iterator.h ../../basic/include/basic/Tuple.c \ + ../../basic/include/basic/ConstString.h ../../basic/include/basic/List.h \ + ../../basic/include/basic/Link.h ../../basic/include/basic/List.c \ + /usr/include/c++/4.4/map /usr/include/c++/4.4/bits/stl_tree.h \ + /usr/include/c++/4.4/bits/stl_map.h \ + /usr/include/c++/4.4/bits/stl_multimap.h \ + ../../omega_lib/include/omega/pres_cnstr.h /usr/include/c++/4.4/vector \ + /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc \ + ../../omega_lib/include/omega/pres_subs.h \ + ../../omega_lib/include/omega/Relation.h \ + ../../omega_lib/include/omega/RelBody.h \ + ../../omega_lib/include/omega/pres_form.h \ + ../../omega_lib/include/omega/pres_dnf.h /usr/include/c++/4.4/iostream \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/limits.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/i386-linux-gnu/bits/posix1_lim.h \ + /usr/include/i386-linux-gnu/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/i386-linux-gnu/bits/posix2_lim.h \ + /usr/include/i386-linux-gnu/bits/xopen_lim.h \ + ../../omega_lib/include/omega/Relations.h \ + ../../omega_lib/include/omega/pres_conj.h \ + ../../omega_lib/include/omega/pres_decl.h \ + ../../basic/include/basic/Section.h ../../basic/include/basic/Section.c \ + ../../omega_lib/include/omega/pres_logic.h \ + ../../omega_lib/include/omega/pres_quant.h \ + ../../omega_lib/include/omega/pres_cmpr.h \ + ../../omega_lib/include/omega/Rel_map.h \ + ../../omega_lib/include/omega/farkas.h \ + ../../omega_lib/include/omega/hull.h \ + ../../omega_lib/include/omega/closure.h ../include/code_gen/codegen.h \ + ../include/code_gen/CG.h ../../basic/include/basic/boolset.h \ + /usr/include/c++/4.4/iterator \ + /usr/include/c++/4.4/bits/stream_iterator.h \ + ../include/code_gen/CG_outputBuilder.h \ + ../include/code_gen/CG_outputRepr.h \ + ../include/code_gen/CG_stringBuilder.h \ + ../include/code_gen/CG_stringRepr.h ../include/code_gen/CG_utils.h \ + /usr/include/c++/4.4/set /usr/include/c++/4.4/bits/stl_set.h \ + /usr/include/c++/4.4/bits/stl_multiset.h \ + ../include/code_gen/codegen_error.h /usr/include/c++/4.4/stack \ + /usr/include/c++/4.4/deque /usr/include/c++/4.4/bits/stl_deque.h \ + /usr/include/c++/4.4/bits/deque.tcc \ + /usr/include/c++/4.4/bits/stl_stack.h /usr/include/string.h +CG_utils.o: ../src/CG_utils.cc /usr/include/c++/4.4/typeinfo \ + /usr/include/c++/4.4/exception \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/features.h /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + ../../omega_lib/include/omega.h \ + ../../omega_lib/include/omega/omega_core/debugging.h \ + /usr/include/stdio.h /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h \ + /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/libio.h \ + /usr/include/_G_config.h /usr/include/wchar.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h /usr/include/ctype.h \ + /usr/include/endian.h /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h /usr/include/xlocale.h \ + ../../omega_lib/include/omega/pres_var.h \ + ../../omega_lib/include/omega/pres_gen.h \ + ../../omega_lib/include/omega/omega_core/oc.h \ + /usr/include/c++/4.4/string /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/stl_algobase.h /usr/include/c++/4.4/cstddef \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/postypes.h \ + /usr/include/c++/4.4/cwchar /usr/include/i386-linux-gnu/bits/wchar.h \ + /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h /usr/include/time.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/basic_string.tcc \ + ../../basic/include/basic/util.h /usr/include/stdlib.h \ + /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h \ + /usr/include/i386-linux-gnu/sys/types.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h /usr/include/alloca.h \ + /usr/include/assert.h /usr/include/c++/4.4/sstream \ + /usr/include/c++/4.4/istream /usr/include/c++/4.4/ios \ + /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/bits/ostream.tcc \ + /usr/include/c++/4.4/bits/istream.tcc \ + /usr/include/c++/4.4/bits/sstream.tcc /usr/include/c++/4.4/stdexcept \ + ../../basic/include/basic/Tuple.h ../../basic/include/basic/Collection.h \ + ../../basic/include/basic/Iterator.h ../../basic/include/basic/Tuple.c \ + ../../basic/include/basic/ConstString.h ../../basic/include/basic/List.h \ + ../../basic/include/basic/Link.h ../../basic/include/basic/List.c \ + /usr/include/c++/4.4/map /usr/include/c++/4.4/bits/stl_tree.h \ + /usr/include/c++/4.4/bits/stl_map.h \ + /usr/include/c++/4.4/bits/stl_multimap.h \ + ../../omega_lib/include/omega/pres_cnstr.h /usr/include/c++/4.4/vector \ + /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc \ + ../../omega_lib/include/omega/pres_subs.h \ + ../../omega_lib/include/omega/Relation.h \ + ../../omega_lib/include/omega/RelBody.h \ + ../../omega_lib/include/omega/pres_form.h \ + ../../omega_lib/include/omega/pres_dnf.h /usr/include/c++/4.4/iostream \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/limits.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/i386-linux-gnu/bits/posix1_lim.h \ + /usr/include/i386-linux-gnu/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/i386-linux-gnu/bits/posix2_lim.h \ + /usr/include/i386-linux-gnu/bits/xopen_lim.h \ + ../../omega_lib/include/omega/Relations.h \ + ../../omega_lib/include/omega/pres_conj.h \ + ../../omega_lib/include/omega/pres_decl.h \ + ../../basic/include/basic/Section.h ../../basic/include/basic/Section.c \ + ../../omega_lib/include/omega/pres_logic.h \ + ../../omega_lib/include/omega/pres_quant.h \ + ../../omega_lib/include/omega/pres_cmpr.h \ + ../../omega_lib/include/omega/Rel_map.h \ + ../../omega_lib/include/omega/farkas.h \ + ../../omega_lib/include/omega/hull.h \ + ../../omega_lib/include/omega/closure.h ../include/code_gen/CG.h \ + ../../basic/include/basic/boolset.h /usr/include/c++/4.4/iterator \ + /usr/include/c++/4.4/bits/stream_iterator.h \ + ../include/code_gen/CG_outputBuilder.h \ + ../include/code_gen/CG_outputRepr.h ../include/code_gen/CG_utils.h \ + /usr/include/c++/4.4/set /usr/include/c++/4.4/bits/stl_set.h \ + /usr/include/c++/4.4/bits/stl_multiset.h \ + ../include/code_gen/codegen_error.h /usr/include/math.h \ + /usr/include/i386-linux-gnu/bits/huge_val.h \ + /usr/include/i386-linux-gnu/bits/huge_valf.h \ + /usr/include/i386-linux-gnu/bits/huge_vall.h \ + /usr/include/i386-linux-gnu/bits/inf.h \ + /usr/include/i386-linux-gnu/bits/nan.h \ + /usr/include/i386-linux-gnu/bits/mathdef.h \ + /usr/include/i386-linux-gnu/bits/mathcalls.h /usr/include/c++/4.4/stack \ + /usr/include/c++/4.4/deque /usr/include/c++/4.4/bits/stl_deque.h \ + /usr/include/c++/4.4/bits/deque.tcc \ + /usr/include/c++/4.4/bits/stl_stack.h +rose_attributes.o: ../src/rose_attributes.cc \ + ../include/code_gen/rose_attributes.h \ + /homes/shanthar/softwares/rose_inst/include/rose.h \ + /homes/shanthar/softwares/rose_inst/include/rosePublicConfig.h \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.hhh \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.h \ + /usr/include/inttypes.h /usr/include/features.h \ + /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h /usr/include/stdint.h \ + /usr/include/i386-linux-gnu/bits/wchar.h /usr/include/semaphore.h \ + /usr/include/i386-linux-gnu/sys/types.h \ + /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/time.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h /usr/include/endian.h \ + /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h \ + /usr/include/i386-linux-gnu/bits/semaphore.h \ + /homes/shanthar/softwares/rose_inst/include/fileoffsetbits.h \ + /homes/shanthar/softwares/rose_inst/include/rosedll.h \ + /homes/shanthar/softwares/rose_inst/include/rose_paths.h \ + /usr/include/c++/4.4/string \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/stl_algobase.h /usr/include/c++/4.4/cstddef \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/postypes.h \ + /usr/include/c++/4.4/cwchar /usr/include/wchar.h /usr/include/stdio.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/xlocale.h /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/exception /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/ctype.h \ + /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/basic_string.tcc \ + /usr/include/i386-linux-gnu/sys/stat.h \ + /usr/include/i386-linux-gnu/bits/stat.h /usr/include/c++/4.4/algorithm \ + /usr/include/c++/4.4/bits/stl_algo.h /usr/include/c++/4.4/cstdlib \ + /usr/include/stdlib.h /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h /usr/include/alloca.h \ + /usr/include/c++/4.4/bits/algorithmfwd.h \ + /usr/include/c++/4.4/bits/stl_heap.h \ + /usr/include/c++/4.4/bits/stl_tempbuf.h \ + /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/fstream /usr/include/c++/4.4/istream \ + /usr/include/c++/4.4/ios /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/bits/ostream.tcc \ + /usr/include/c++/4.4/bits/istream.tcc \ + /usr/include/c++/4.4/bits/codecvt.h /usr/include/c++/4.4/cstdio \ + /usr/include/libio.h /usr/include/_G_config.h \ + /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/basic_file.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++io.h \ + /usr/include/c++/4.4/bits/fstream.tcc \ + /homes/shanthar/softwares/rose_inst/include/rosedefs.h \ + /usr/include/c++/4.4/cassert /usr/include/assert.h \ + /usr/include/c++/4.4/list /usr/include/c++/4.4/bits/stl_list.h \ + /usr/include/c++/4.4/bits/list.tcc /usr/include/c++/4.4/vector \ + /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc /usr/include/c++/4.4/set \ + /usr/include/c++/4.4/bits/stl_tree.h /usr/include/c++/4.4/bits/stl_set.h \ + /usr/include/c++/4.4/bits/stl_multiset.h /usr/include/c++/4.4/map \ + /usr/include/c++/4.4/bits/stl_map.h \ + /usr/include/c++/4.4/bits/stl_multimap.h /usr/include/c++/4.4/sstream \ + /usr/include/c++/4.4/bits/sstream.tcc \ + /homes/shanthar/softwares/rose_inst/include/roseInternal.h \ + /homes/shanthar/softwares/rose_inst/include/rose_msvc.h \ + /homes/shanthar/softwares/rose_inst/include/processSupport.h \ + /homes/shanthar/softwares/rose_inst/include/virtualCFG.h \ + /homes/shanthar/softwares/rose_inst/include/virtualBinCFG.h \ + /homes/shanthar/softwares/rose_inst/include/staticCFG.h \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.h \ + /homes/shanthar/softwares/rose_inst/include/AstAttributeMechanism.h \ + /homes/shanthar/softwares/rose_inst/include/AttributeMechanism.h \ + /usr/include/c++/4.4/iostream \ + /homes/shanthar/softwares/rose_inst/include/rose_attributes_list.h \ + /homes/shanthar/softwares/rose_inst/include/general_token_defs.h \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/iterate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/dec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/config/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/inc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/data.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/cat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/slot.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/detail/def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_token.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/wave_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/user.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_compiler_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/compiler/gcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_stdlib_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/utility.hpp \ + /usr/include/c++/4.4/utility /usr/include/c++/4.4/bits/stl_relops.h \ + /homes/shanthar/softwares/boost_inst/include/boost/config/stdlib/libstdcpp3.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_platform_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/platform/linux.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/posix_features.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/workaround.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/wave_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/flex_string.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/throw_exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/exception/detail/attribute_noreturn.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/exception/exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/current_function.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/reverse_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator.hpp \ + /usr/include/c++/4.4/iterator \ + /usr/include/c++/4.4/bits/stream_iterator.h \ + /homes/shanthar/softwares/boost_inst/include/boost/utility.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/addressof.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/base_from_member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_binary_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/punctuation/comma_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/iif.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/punctuation/comma.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/repeat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/debug/error.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/auto_rec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/eat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/rem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/repeat_from_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/add.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/while.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/detail/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/expr_iif.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/adt.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/is_binary.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/check.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/compl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/fold_right.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/detail/fold_right.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/reverse.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/bitand.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/detail/while.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/sub.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/binary.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/deduce_d.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/cat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/seq.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/mod.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/detail/div_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/comparison/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/enable_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/checked_delete.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/next_prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/noncopyable.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_adaptor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/static_assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_categories.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/config_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/eval_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/value_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/static_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/workaround.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/integral.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/msvc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/eti.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/lambda_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/void_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/adl_barrier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/adl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/intel.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/gcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bool_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/static_constant.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/ctps.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/ttp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/int.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/int_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/nttp_decl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/nttp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/integral_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_arity_param.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/template_arity_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/dtp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/preprocessor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/comma_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repeat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/inc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/limits/arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/overload_resolution.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/placeholders.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/arg_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/nested_type_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/yes_no.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/arrays.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/pp_counter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arity_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arg_typedef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/use_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/include_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/compiler.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/stringize.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_convertible.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/intrinsics.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_same.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/bool_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/template_arity_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/integral_constant.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/bool_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_lvalue_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_rvalue_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/ice.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/yes_no_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_eq.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/cv_traits_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_array.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/type_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/type_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_arithmetic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_integral.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_float.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_abstract.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/config_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_facade.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/interoperable.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/facade_iterator_category.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/indirect_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_function.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/false_result.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/is_function_ptr_helper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_function_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_cv.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/broken_compiler_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_class.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/enable_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/implicit_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_pod.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_scalar.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/always.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply_wrap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_xxx.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/type_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/has_xxx.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/msvc_typename.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_trailing_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/has_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_never_true.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bind_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/next.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/next_prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/common_name_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/protect.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/full_lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/quote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/bcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/template_arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp \ + /usr/include/c++/4.4/memory \ + /usr/include/c++/4.4/bits/stl_raw_storage_iter.h \ + /usr/include/c++/4.4/backward/auto_ptr.h /usr/include/c++/4.4/functional \ + /usr/include/c++/4.4/limits /usr/include/c++/4.4/stdexcept \ + /usr/include/c++/4.4/cstring /usr/include/string.h \ + /homes/shanthar/softwares/boost_inst/include/boost/config/auto_link.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/file_position.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_position_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/position_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept_check.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/general.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/backward_compatibility.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/has_constraints.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/conversion_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/usage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/concept_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/for_each_i.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/for.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/detail/for.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/concept_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/namespace.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/position_iterator_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/core/nil.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/impl/position_iterator.ipp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator_adaptors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/token_ids.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/language_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/singleton_pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/poolfwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/mutex.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/ct_gcd_lcm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/gcd_lcm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/simple_segregated_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/singleton.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/guard.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/atomic_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/atomic_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_has_sync.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/intrusive_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/intrusive_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_convertible.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/functional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/operator_bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/support_multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/first_owner_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/multi_pass_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/multi_pass_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/detail/scoped_enum_emulation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/scoped_enum_emulation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/input_iterator_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/buffering_input_iterator_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/istream_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/lex_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/functor_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/no_check_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/fixed_size_queue_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/fixed_size_queue.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/combine_policies.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/limits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/functor_input.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/multi_pass.hpp \ + /usr/include/c++/4.4/deque /usr/include/c++/4.4/bits/stl_deque.h \ + /usr/include/c++/4.4/bits/deque.tcc \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/core/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/fixed_size_queue.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/multi_pass_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_interface_generator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_interface.hpp \ + /homes/shanthar/softwares/rose_inst/include/string_functions.h \ + /homes/shanthar/softwares/rose_inst/include/commandline_processing.h \ + /homes/shanthar/softwares/rose_inst/include/setup.h \ + /usr/include/c++/4.4/stack /usr/include/c++/4.4/bits/stl_stack.h \ + /homes/shanthar/softwares/rose_inst/include/escape.h \ + /homes/shanthar/softwares/rose_inst/include/sla.h \ + /homes/shanthar/softwares/rose_inst/include/Cxx_Grammar.h \ + /homes/shanthar/softwares/rose_inst/include/rangemap.h \ + /usr/include/c++/4.4/cmath /usr/include/math.h \ + /usr/include/i386-linux-gnu/bits/huge_val.h \ + /usr/include/i386-linux-gnu/bits/huge_valf.h \ + /usr/include/i386-linux-gnu/bits/huge_vall.h \ + /usr/include/i386-linux-gnu/bits/inf.h \ + /usr/include/i386-linux-gnu/bits/nan.h \ + /usr/include/i386-linux-gnu/bits/mathdef.h \ + /usr/include/i386-linux-gnu/bits/mathcalls.h \ + /usr/include/c++/4.4/bits/cmath.tcc \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_map_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/hash_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/hash.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/hash_float.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/float_functions.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/cmath.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/limits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer/static_log2.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer_fwd.hpp \ + /usr/include/c++/4.4/climits \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/limits.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/i386-linux-gnu/bits/posix1_lim.h \ + /usr/include/i386-linux-gnu/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/i386-linux-gnu/bits/posix2_lim.h \ + /usr/include/i386-linux-gnu/bits/xopen_lim.h \ + /homes/shanthar/softwares/boost_inst/include/boost/cstdint.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/hash_float_generic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/extensions.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/container_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/allocator_helpers.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/equivalent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/table.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/buckets.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/node.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/compressed_pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/compressed_pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/call_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/call_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/aligned_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/aligned_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/alignment_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/size_t_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_t.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_t_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/size_t_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/type_with_alignment.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/for_each_i.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/to_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/append.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/util.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/extract_key.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/unique.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/move.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered_set.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_set.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_set_fwd.hpp \ + /homes/shanthar/softwares/rose_inst/include/Cxx_Grammar.h \ + /homes/shanthar/softwares/rose_inst/include/InstructionEnumsX86.h \ + /homes/shanthar/softwares/rose_inst/include/AssemblerX86Init.h \ + /homes/shanthar/softwares/rose_inst/include/armInstructionEnum.h \ + /homes/shanthar/softwares/rose_inst/include/powerpcInstructionEnum.h \ + /homes/shanthar/softwares/rose_inst/include/DataConversion.h \ + /homes/shanthar/softwares/rose_inst/include/utility_functions.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/DOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSuccessorsSelectors.h \ + /homes/shanthar/softwares/rose_inst/include/StackFrameVector.h \ + /homes/shanthar/softwares/rose_inst/include/Cxx_GrammarTreeTraversalAccessEnums.h \ + /homes/shanthar/softwares/rose_inst/include/AstSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedProcessingImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelProcessingImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/DOTRepresentation.h \ + /homes/shanthar/softwares/rose_inst/include/DOTRepresentationImpl.h \ + /usr/include/c++/4.4/typeinfo \ + /homes/shanthar/softwares/rose_inst/include/DOTGenerationImpl.h \ + /homes/shanthar/softwares/rose_inst/include/sageInterface.h \ + /homes/shanthar/softwares/rose_inst/include/sage3.h \ + /homes/shanthar/softwares/rose_inst/include/attachPreprocessingInfo.h \ + /homes/shanthar/softwares/rose_inst/include/attachPreprocessingInfoTraversal.h \ + /homes/shanthar/softwares/rose_inst/include/attach_all_info.h \ + /homes/shanthar/softwares/rose_inst/include/astPostProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstFixup.h \ + /homes/shanthar/softwares/rose_inst/include/fixupforGnuBackendCompiler.h \ + /homes/shanthar/softwares/rose_inst/include/fixupFunctionDefinitions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupInClassDataInitialization.h \ + /homes/shanthar/softwares/rose_inst/include/fixupStorageAccessOfForwardTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/removeInitializedNamePtr.h \ + /homes/shanthar/softwares/rose_inst/include/AstNodePtrs.h \ + /usr/include/c++/4.4/iomanip \ + /homes/shanthar/softwares/rose_inst/include/fixupSourcePositionInformation.h \ + /homes/shanthar/softwares/rose_inst/include/fixupEnumValues.h \ + /homes/shanthar/softwares/rose_inst/include/fixupFriendTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupPrettyFunction.h \ + /homes/shanthar/softwares/rose_inst/include/resetParentPointers.h \ + /homes/shanthar/softwares/rose_inst/include/AstNodeVisitMapping.h \ + /homes/shanthar/softwares/rose_inst/include/processTemplateHandlingOptions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupSymbolTables.h \ + /homes/shanthar/softwares/rose_inst/include/markCompilerGenerated.h \ + /homes/shanthar/softwares/rose_inst/include/markTemplateInstantiationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/resetTemplateNames.h \ + /homes/shanthar/softwares/rose_inst/include/fixupDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTemplateInstantiations.h \ + /homes/shanthar/softwares/rose_inst/include/markForOutputInCodeGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/markTemplateSpecializationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/initializeExplicitScopeData.h \ + /homes/shanthar/softwares/rose_inst/include/fixupDefiningAndNondefiningDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/markOverloadedTemplateInstantiations.h \ + /homes/shanthar/softwares/rose_inst/include/markTransformationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/markBackendCompilerSpecificFunctions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupNullPointers.h \ + /homes/shanthar/softwares/rose_inst/include/checkIsModifiedFlag.h \ + /homes/shanthar/softwares/rose_inst/include/fixupNames.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTypes.h \ + /homes/shanthar/softwares/rose_inst/include/fixupConstructorPreinitializationLists.h \ + /homes/shanthar/softwares/rose_inst/include/propagateHiddenListData.h \ + /homes/shanthar/softwares/rose_inst/include/markLhsValues.h \ + /homes/shanthar/softwares/rose_inst/include/resolveFortranReferences.h \ + /homes/shanthar/softwares/rose_inst/include/insertFortranContainsStatement.h \ + /homes/shanthar/softwares/rose_inst/include/fixupUseAndUsingDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupCxxSymbolTablesToSupportAliasingSymbols.h \ + /homes/shanthar/softwares/rose_inst/include/normalizeTypedefSequenceLists.h \ + /homes/shanthar/softwares/rose_inst/include/fixupConstantFoldedValues.h \ + /homes/shanthar/softwares/rose_inst/include/fixupSelfReferentialMacros.h \ + /homes/shanthar/softwares/rose_inst/include/abstract_handle.h \ + /homes/shanthar/softwares/rose_inst/include/roseAdapter.h \ + /homes/shanthar/softwares/rose_inst/include/memory_object.h \ + /homes/shanthar/softwares/rose_inst/include/sageBuilder.h \ + /homes/shanthar/softwares/rose_inst/include/sageBuilderAsm.h \ + /homes/shanthar/softwares/rose_inst/include/omp_lowering.h \ + /homes/shanthar/softwares/rose_inst/include/astQuery.h \ + /homes/shanthar/softwares/rose_inst/include/astQueryInheritedAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/AstQueryMemoryPool.h \ + /homes/shanthar/softwares/rose_inst/include/astMergeAPI.h \ + /homes/shanthar/softwares/rose_inst/include/AstFromString.h \ + /homes/shanthar/softwares/rose_inst/include/rose.h \ + /homes/shanthar/softwares/rose_inst/include/ParserBuilder.hpp \ + /homes/shanthar/softwares/rose_inst/include/ParserBuilder.tpp \ + /homes/shanthar/softwares/rose_inst/include/rewrite.h \ + /homes/shanthar/softwares/rose_inst/include/AstReverseProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstReverseSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstClearVisitFlags.h \ + /homes/shanthar/softwares/rose_inst/include/transformationSupport.h \ + /homes/shanthar/softwares/rose_inst/include/optionDeclaration.h \ + /homes/shanthar/softwares/rose_inst/include/roseQueryLib.h \ + /homes/shanthar/softwares/rose_inst/include/booleanQuery.h \ + /homes/shanthar/softwares/rose_inst/include/nodeQuery.h \ + /homes/shanthar/softwares/rose_inst/include/nameQuery.h \ + /homes/shanthar/softwares/rose_inst/include/numberQuery.h \ + /homes/shanthar/softwares/rose_inst/include/lowLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/midLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/highLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/astUnparseAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/LivenessAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/filteredCFG.h \ + /homes/shanthar/softwares/rose_inst/include/filteredCFGImpl.h \ + /homes/shanthar/softwares/rose_inst/include/DefUseAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/DFAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/support.h \ + /homes/shanthar/softwares/rose_inst/include/DFAFilter.h \ + /homes/shanthar/softwares/rose_inst/include/DefUseAnalysisAbstract.h \ + /homes/shanthar/softwares/rose_inst/include/virtualCFG.h \ + /homes/shanthar/softwares/rose_inst/include/cfgToDot.h \ + /homes/shanthar/softwares/rose_inst/include/dfaToDot.h \ + /homes/shanthar/softwares/rose_inst/include/ClassHierarchyGraph.h \ + /homes/shanthar/softwares/rose_inst/include/manglingSupport.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_support.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_exprTree.h \ + /usr/include/i386-linux-gnu/sys/time.h \ + /homes/shanthar/softwares/rose_inst/include/x86InstructionProperties.h \ + /homes/shanthar/softwares/rose_inst/include/AstPerformance.h \ + /homes/shanthar/softwares/rose_inst/include/unparser.h \ + /homes/shanthar/softwares/rose_inst/include/unparser_opt.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_format.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFormatHelp.h \ + /homes/shanthar/softwares/rose_inst/include/unparseCxx_types.h \ + /homes/shanthar/softwares/rose_inst/include/name_qualification_support.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_sym.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_debug.h \ + /homes/shanthar/softwares/rose_inst/include/modified_sage.h \ + /homes/shanthar/softwares/rose_inst/include/unparseCxx.h \ + /homes/shanthar/softwares/rose_inst/include/unparseLanguageIndependentConstructs.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFortran.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFortran_types.h \ + /homes/shanthar/softwares/rose_inst/include/unparseJava.h \ + /homes/shanthar/softwares/rose_inst/include/unparsePHP.h \ + /homes/shanthar/softwares/rose_inst/include/unparsePython.h \ + /homes/shanthar/softwares/rose_inst/include/AstPDFGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstDiagnostics.h \ + /homes/shanthar/softwares/rose_inst/include/AstConsistencyTests.h \ + /homes/shanthar/softwares/rose_inst/include/AstStatistics.h \ + /homes/shanthar/softwares/rose_inst/include/AstTextAttributesHandling.h \ + /homes/shanthar/softwares/rose_inst/include/AstWarnings.h \ + /homes/shanthar/softwares/rose_inst/include/Ast.h \ + /homes/shanthar/softwares/rose_inst/include/wholeAST_API.h \ + /homes/shanthar/softwares/rose_inst/include/wholeAST.h \ + /homes/shanthar/softwares/rose_inst/include/copyGraph.h \ + /homes/shanthar/softwares/rose_inst/include/roseTranslators.h \ + /homes/shanthar/softwares/rose_inst/include/Translator.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstPDFGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstConsistencyTests.h \ + /homes/shanthar/softwares/rose_inst/include/merge.h \ + /homes/shanthar/softwares/rose_inst/include/test_support.h \ + /homes/shanthar/softwares/rose_inst/include/merge_support.h \ + /homes/shanthar/softwares/rose_inst/include/nullifyAST.h \ + /homes/shanthar/softwares/rose_inst/include/buildMangledNameMap.h \ + /homes/shanthar/softwares/rose_inst/include/deleteOrphanNodes.h \ + /homes/shanthar/softwares/rose_inst/include/buildReplacementMap.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTraversal.h \ + /homes/shanthar/softwares/rose_inst/include/collectAssociateNodes.h \ + /homes/shanthar/softwares/rose_inst/include/requiredNodes.h \ + /homes/shanthar/softwares/rose_inst/include/AST_FILE_IO.h \ + /homes/shanthar/softwares/rose_inst/include/AstSpecificDataManagingClass.h \ + /homes/shanthar/softwares/rose_inst/include/astGraph.h \ + /homes/shanthar/softwares/rose_inst/include/astGraphTemplateImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstAttributeDOT.h \ + /homes/shanthar/softwares/rose_inst/include/inliner.h \ + /homes/shanthar/softwares/rose_inst/include/replaceExpressionWithStatement.h \ + /homes/shanthar/softwares/rose_inst/include/inlinerSupport.h \ + /homes/shanthar/softwares/rose_inst/include/pre.h \ + /usr/include/c++/4.4/queue /usr/include/c++/4.4/bits/stl_queue.h \ + /homes/shanthar/softwares/rose_inst/include/expressionTreeEqual.h \ + /homes/shanthar/softwares/rose_inst/include/controlFlowGraph.h \ + /homes/shanthar/softwares/rose_inst/include/CFG.h \ + /homes/shanthar/softwares/rose_inst/include/AstInterface.h \ + /homes/shanthar/softwares/rose_inst/include/ObserveObject.h \ + /homes/shanthar/softwares/rose_inst/include/PtrSet.h \ + /homes/shanthar/softwares/rose_inst/include/FunctionObject.h \ + /homes/shanthar/softwares/rose_inst/include/PtrMap.h \ + /homes/shanthar/softwares/rose_inst/include/ProcessAstTree.h \ + /homes/shanthar/softwares/rose_inst/include/AstInterface.h \ + /homes/shanthar/softwares/rose_inst/include/SinglyLinkedList.h \ + /homes/shanthar/softwares/rose_inst/include/CommandOptions.h \ + /homes/shanthar/softwares/rose_inst/include/constantFolding.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList_Output.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList_Intersection.h \ + /homes/shanthar/softwares/rose_inst/include/cfgToDot.h \ + /homes/shanthar/softwares/rose_inst/include/MemoryMap.h \ + /homes/shanthar/softwares/boost_inst/include/boost/shared_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/shared_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/memory.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/shared_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/bad_weak_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/sp_typeinfo.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock_pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock_sync.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/yield_k.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/memory_order.hpp \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_abstract.h \ + /homes/shanthar/softwares/rose_inst/include/RoseFile.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_file.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_substTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_buildTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_buildTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_callGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_branchGraph.h \ + /usr/include/c++/4.4/cxxabi.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cxxabi_tweaks.h \ + /homes/shanthar/softwares/rose_inst/include/RoseObj.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DotGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_Graph.h \ + /homes/shanthar/softwares/rose_inst/include/SB_Graph.h \ + /homes/shanthar/softwares/rose_inst/include/MyAstAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_GmlGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_ControlFlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_FlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/GraphAlgorithms.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DataFlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DefUseAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DataFlowAbstract.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_Emulate.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_VariableAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_CallGraphAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/AST_BIN_Traversal.h \ + /homes/shanthar/softwares/rose_inst/include/AsmUnparser_compat.h \ + /homes/shanthar/softwares/rose_inst/include/AsmUnparser.h \ + /homes/shanthar/softwares/rose_inst/include/callbacks.h \ + /homes/shanthar/softwares/rose_inst/include/threadSupport.h \ + /homes/shanthar/softwares/rose_inst/include/BinaryControlFlow.h \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/adjacency_list.hpp \ + /usr/include/c++/4.4/ext/slist \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/tuple/tuple.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/ref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/tuple/detail/tuple_basic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/cv_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_cv.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/function_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/property.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/detail/property.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/same_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_mutability_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_selectors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/cstddef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept_archetype.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/vector_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/edge.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/properties.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/property_maps/constant_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/property_maps/null_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/named_graph.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index_container.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/allocator_utilities.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/no_exceptions_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/at.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/at_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/at_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin_end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin_end_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/begin_end_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/sequence_tag_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_begin.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/traits_lambda_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/sequence_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/is_msvc_eti_arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/advance.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/advance_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/less.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/comparison_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/numeric_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/numeric_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/numeric_cast_utils.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/forwarding.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_eti_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/less.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/negate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/long.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/long_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/advance_forward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/advance_backward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/deref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/contains.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/contains_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/contains_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/find.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/find_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/find_if_pred.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iter_fold_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/logical.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_fold_if_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/same_as.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/distance.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/distance_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iter_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/O1_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/O1_size_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/O1_size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_range.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index_container_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/identity_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/indexed_by.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/limits/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector20.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector10.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/at.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/typeof.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/push_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/item.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/pop_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pop_front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/push_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/pop_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pop_back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/clear.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/clear_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/vector0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_tags.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/plus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arithmetic_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/largest_int.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/minus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/O1_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/empty_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/begin_end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/include_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/expr_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/ordered_index_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/ord_index_args.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/no_duplicate_tags.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/set0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/at_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/has_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_key_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/overload_names.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/ptr_to_ref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/operators.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/clear_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/set0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/empty_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/insert_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/insert_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/item.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/erase_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/erase_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/erase_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/erase_key_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/key_type_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/key_type_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/value_type_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/value_type_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/begin_end_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_key.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/reverse_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/reverse_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pair_view.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_category.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/min_max.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/is_sequence.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/inserter_algorithm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/back_inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/push_back_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/front_inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/push_front_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/clear.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/clear_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/default_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/intercept.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_base_and_derived.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/access_specifier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/adl_swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/base_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/copy_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/auto_space.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/prevent_eti.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/node_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/reverse_iter_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/header_holder.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_node_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/archive_exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/decl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/abi_prefix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/abi_prefix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/abi_suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/abi_suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/access.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/pfto.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/is_index_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/empty_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/msvc_index_specifier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_loader.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/nvp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/level.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_fundamental.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/level_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/tracking.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/greater.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/tracking_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/type_info_implementation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/split_member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/base_object.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_polymorphic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/force_include.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/void_cast_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_saver.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_matcher.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/converter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/has_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/safe_mode.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/scope_guard.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/archive_constructed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/serialization.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/basic_archive.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/auto_link_archive.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/strong_typedef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/operators.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/serialization_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/comparison.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/not_equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/greater_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/collection_size_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/split_free.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/hashed_index.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/bucket_array.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_node.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/modify_key_adaptor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/safe_ctr_proxy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/hashed_index_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_args.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional/optional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/reference_content.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_copy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_copy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/none.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/none_t.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/compare_pointees.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional/optional_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/adjacency_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/integer_range.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/counting_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/numeric_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_new_operator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_assign.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_assign.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_constructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_constructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_virtual_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_signed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_unsigned.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_base_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_compound.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_floating_point.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_object_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_object.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_stateless.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_union.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_virtual_base_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/rank.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/extent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_bounds.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_extent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_all_extents.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/floating_point_promotion.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/integral_promotion.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/promote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/make_unsigned.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/make_signed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/decay.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_complex.hpp \ + /usr/include/c++/4.4/complex \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/select_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_concepts.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/numeric_values.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/container_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/adj_list_edge_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/adjacency_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/depth_first_search.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/visitors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/named_function_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/name.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/keyword.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/unwrap_cv_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/yesno.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/tagged_argument.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/arg_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/result_of0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/result_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_shifted_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/iter/forward1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/detail/shared.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/detail/result_of_iterate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/default.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/parameter_requirements.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/is_maybe.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/value_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/binding.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/shared_array_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/shared_array.hpp \ + /homes/shanthar/softwares/rose_inst/include/BinaryFunctionCall.h \ + /homes/shanthar/softwares/rose_inst/include/Disassembler.h \ + /homes/shanthar/softwares/rose_inst/include/Registers.h \ + /homes/shanthar/softwares/rose_inst/include/powerpcInstructionProperties.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerArm.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerPowerpc.h \ + /homes/shanthar/softwares/rose_inst/include/integerOps.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerX86.h \ + /homes/shanthar/softwares/rose_inst/include/Partitioner.h \ + /homes/shanthar/softwares/rose_inst/include/Assembler.h \ + /homes/shanthar/softwares/rose_inst/include/AssemblerX86.h \ + /homes/shanthar/softwares/rose_inst/include/abiStuff.h \ + /homes/shanthar/softwares/rose_inst/include/ether.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGenerationImpl.C \ + /homes/shanthar/softwares/rose_inst/include/utility_functionsImpl.C +CG_roseRepr.o: ../src/CG_roseRepr.cc ../include/code_gen/CG_roseRepr.h \ + ../include/code_gen/CG_outputRepr.h \ + /homes/shanthar/softwares/rose_inst/include/rose.h \ + /homes/shanthar/softwares/rose_inst/include/rosePublicConfig.h \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.hhh \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.h \ + /usr/include/inttypes.h /usr/include/features.h \ + /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h /usr/include/stdint.h \ + /usr/include/i386-linux-gnu/bits/wchar.h /usr/include/semaphore.h \ + /usr/include/i386-linux-gnu/sys/types.h \ + /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/time.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h /usr/include/endian.h \ + /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h \ + /usr/include/i386-linux-gnu/bits/semaphore.h \ + /homes/shanthar/softwares/rose_inst/include/fileoffsetbits.h \ + /homes/shanthar/softwares/rose_inst/include/rosedll.h \ + /homes/shanthar/softwares/rose_inst/include/rose_paths.h \ + /usr/include/c++/4.4/string \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/stl_algobase.h /usr/include/c++/4.4/cstddef \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/postypes.h \ + /usr/include/c++/4.4/cwchar /usr/include/wchar.h /usr/include/stdio.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/xlocale.h /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/exception /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/ctype.h \ + /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/basic_string.tcc \ + /usr/include/i386-linux-gnu/sys/stat.h \ + /usr/include/i386-linux-gnu/bits/stat.h /usr/include/c++/4.4/algorithm \ + /usr/include/c++/4.4/bits/stl_algo.h /usr/include/c++/4.4/cstdlib \ + /usr/include/stdlib.h /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h /usr/include/alloca.h \ + /usr/include/c++/4.4/bits/algorithmfwd.h \ + /usr/include/c++/4.4/bits/stl_heap.h \ + /usr/include/c++/4.4/bits/stl_tempbuf.h \ + /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/fstream /usr/include/c++/4.4/istream \ + /usr/include/c++/4.4/ios /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/bits/ostream.tcc \ + /usr/include/c++/4.4/bits/istream.tcc \ + /usr/include/c++/4.4/bits/codecvt.h /usr/include/c++/4.4/cstdio \ + /usr/include/libio.h /usr/include/_G_config.h \ + /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/basic_file.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++io.h \ + /usr/include/c++/4.4/bits/fstream.tcc \ + /homes/shanthar/softwares/rose_inst/include/rosedefs.h \ + /usr/include/c++/4.4/cassert /usr/include/assert.h \ + /usr/include/c++/4.4/list /usr/include/c++/4.4/bits/stl_list.h \ + /usr/include/c++/4.4/bits/list.tcc /usr/include/c++/4.4/vector \ + /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc /usr/include/c++/4.4/set \ + /usr/include/c++/4.4/bits/stl_tree.h /usr/include/c++/4.4/bits/stl_set.h \ + /usr/include/c++/4.4/bits/stl_multiset.h /usr/include/c++/4.4/map \ + /usr/include/c++/4.4/bits/stl_map.h \ + /usr/include/c++/4.4/bits/stl_multimap.h /usr/include/c++/4.4/sstream \ + /usr/include/c++/4.4/bits/sstream.tcc \ + /homes/shanthar/softwares/rose_inst/include/roseInternal.h \ + /homes/shanthar/softwares/rose_inst/include/rose_msvc.h \ + /homes/shanthar/softwares/rose_inst/include/processSupport.h \ + /homes/shanthar/softwares/rose_inst/include/virtualCFG.h \ + /homes/shanthar/softwares/rose_inst/include/virtualBinCFG.h \ + /homes/shanthar/softwares/rose_inst/include/staticCFG.h \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.h \ + /homes/shanthar/softwares/rose_inst/include/AstAttributeMechanism.h \ + /homes/shanthar/softwares/rose_inst/include/AttributeMechanism.h \ + /usr/include/c++/4.4/iostream \ + /homes/shanthar/softwares/rose_inst/include/rose_attributes_list.h \ + /homes/shanthar/softwares/rose_inst/include/general_token_defs.h \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/iterate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/dec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/config/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/inc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/data.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/cat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/slot.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/detail/def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_token.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/wave_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/user.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_compiler_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/compiler/gcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_stdlib_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/utility.hpp \ + /usr/include/c++/4.4/utility /usr/include/c++/4.4/bits/stl_relops.h \ + /homes/shanthar/softwares/boost_inst/include/boost/config/stdlib/libstdcpp3.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_platform_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/platform/linux.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/posix_features.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/workaround.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/wave_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/flex_string.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/throw_exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/exception/detail/attribute_noreturn.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/exception/exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/current_function.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/reverse_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator.hpp \ + /usr/include/c++/4.4/iterator \ + /usr/include/c++/4.4/bits/stream_iterator.h \ + /homes/shanthar/softwares/boost_inst/include/boost/utility.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/addressof.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/base_from_member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_binary_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/punctuation/comma_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/iif.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/punctuation/comma.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/repeat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/debug/error.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/auto_rec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/eat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/rem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/repeat_from_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/add.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/while.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/detail/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/expr_iif.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/adt.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/is_binary.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/check.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/compl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/fold_right.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/detail/fold_right.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/reverse.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/bitand.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/detail/while.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/sub.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/binary.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/deduce_d.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/cat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/seq.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/mod.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/detail/div_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/comparison/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/enable_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/checked_delete.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/next_prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/noncopyable.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_adaptor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/static_assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_categories.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/config_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/eval_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/value_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/static_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/workaround.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/integral.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/msvc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/eti.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/lambda_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/void_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/adl_barrier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/adl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/intel.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/gcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bool_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/static_constant.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/ctps.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/ttp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/int.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/int_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/nttp_decl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/nttp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/integral_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_arity_param.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/template_arity_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/dtp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/preprocessor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/comma_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repeat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/inc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/limits/arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/overload_resolution.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/placeholders.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/arg_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/nested_type_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/yes_no.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/arrays.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/pp_counter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arity_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arg_typedef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/use_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/include_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/compiler.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/stringize.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_convertible.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/intrinsics.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_same.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/bool_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/template_arity_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/integral_constant.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/bool_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_lvalue_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_rvalue_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/ice.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/yes_no_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_eq.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/cv_traits_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_array.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/type_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/type_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_arithmetic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_integral.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_float.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_abstract.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/config_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_facade.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/interoperable.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/facade_iterator_category.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/indirect_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_function.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/false_result.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/is_function_ptr_helper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_function_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_cv.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/broken_compiler_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_class.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/enable_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/implicit_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_pod.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_scalar.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/always.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply_wrap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_xxx.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/type_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/has_xxx.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/msvc_typename.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_trailing_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/has_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_never_true.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bind_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/next.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/next_prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/common_name_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/protect.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/full_lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/quote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/bcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/template_arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp \ + /usr/include/c++/4.4/memory \ + /usr/include/c++/4.4/bits/stl_raw_storage_iter.h \ + /usr/include/c++/4.4/backward/auto_ptr.h /usr/include/c++/4.4/functional \ + /usr/include/c++/4.4/limits /usr/include/c++/4.4/stdexcept \ + /usr/include/c++/4.4/cstring /usr/include/string.h \ + /homes/shanthar/softwares/boost_inst/include/boost/config/auto_link.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/file_position.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_position_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/position_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept_check.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/general.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/backward_compatibility.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/has_constraints.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/conversion_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/usage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/concept_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/for_each_i.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/for.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/detail/for.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/concept_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/namespace.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/position_iterator_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/core/nil.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/impl/position_iterator.ipp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator_adaptors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/token_ids.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/language_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/singleton_pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/poolfwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/mutex.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/ct_gcd_lcm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/gcd_lcm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/simple_segregated_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/singleton.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/guard.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/atomic_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/atomic_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_has_sync.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/intrusive_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/intrusive_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_convertible.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/functional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/operator_bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/support_multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/first_owner_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/multi_pass_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/multi_pass_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/detail/scoped_enum_emulation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/scoped_enum_emulation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/input_iterator_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/buffering_input_iterator_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/istream_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/lex_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/functor_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/no_check_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/fixed_size_queue_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/fixed_size_queue.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/combine_policies.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/limits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/functor_input.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/multi_pass.hpp \ + /usr/include/c++/4.4/deque /usr/include/c++/4.4/bits/stl_deque.h \ + /usr/include/c++/4.4/bits/deque.tcc \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/core/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/fixed_size_queue.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/multi_pass_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_interface_generator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_interface.hpp \ + /homes/shanthar/softwares/rose_inst/include/string_functions.h \ + /homes/shanthar/softwares/rose_inst/include/commandline_processing.h \ + /homes/shanthar/softwares/rose_inst/include/setup.h \ + /usr/include/c++/4.4/stack /usr/include/c++/4.4/bits/stl_stack.h \ + /homes/shanthar/softwares/rose_inst/include/escape.h \ + /homes/shanthar/softwares/rose_inst/include/sla.h \ + /homes/shanthar/softwares/rose_inst/include/Cxx_Grammar.h \ + /homes/shanthar/softwares/rose_inst/include/rangemap.h \ + /usr/include/c++/4.4/cmath /usr/include/math.h \ + /usr/include/i386-linux-gnu/bits/huge_val.h \ + /usr/include/i386-linux-gnu/bits/huge_valf.h \ + /usr/include/i386-linux-gnu/bits/huge_vall.h \ + /usr/include/i386-linux-gnu/bits/inf.h \ + /usr/include/i386-linux-gnu/bits/nan.h \ + /usr/include/i386-linux-gnu/bits/mathdef.h \ + /usr/include/i386-linux-gnu/bits/mathcalls.h \ + /usr/include/c++/4.4/bits/cmath.tcc \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_map_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/hash_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/hash.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/hash_float.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/float_functions.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/cmath.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/limits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer/static_log2.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer_fwd.hpp \ + /usr/include/c++/4.4/climits \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/limits.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/i386-linux-gnu/bits/posix1_lim.h \ + /usr/include/i386-linux-gnu/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/i386-linux-gnu/bits/posix2_lim.h \ + /usr/include/i386-linux-gnu/bits/xopen_lim.h \ + /homes/shanthar/softwares/boost_inst/include/boost/cstdint.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/hash_float_generic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/extensions.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/container_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/allocator_helpers.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/equivalent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/table.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/buckets.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/node.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/compressed_pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/compressed_pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/call_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/call_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/aligned_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/aligned_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/alignment_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/size_t_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_t.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_t_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/size_t_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/type_with_alignment.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/for_each_i.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/to_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/append.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/util.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/extract_key.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/unique.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/move.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered_set.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_set.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_set_fwd.hpp \ + /homes/shanthar/softwares/rose_inst/include/Cxx_Grammar.h \ + /homes/shanthar/softwares/rose_inst/include/InstructionEnumsX86.h \ + /homes/shanthar/softwares/rose_inst/include/AssemblerX86Init.h \ + /homes/shanthar/softwares/rose_inst/include/armInstructionEnum.h \ + /homes/shanthar/softwares/rose_inst/include/powerpcInstructionEnum.h \ + /homes/shanthar/softwares/rose_inst/include/DataConversion.h \ + /homes/shanthar/softwares/rose_inst/include/utility_functions.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/DOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSuccessorsSelectors.h \ + /homes/shanthar/softwares/rose_inst/include/StackFrameVector.h \ + /homes/shanthar/softwares/rose_inst/include/Cxx_GrammarTreeTraversalAccessEnums.h \ + /homes/shanthar/softwares/rose_inst/include/AstSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedProcessingImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelProcessingImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/DOTRepresentation.h \ + /homes/shanthar/softwares/rose_inst/include/DOTRepresentationImpl.h \ + /usr/include/c++/4.4/typeinfo \ + /homes/shanthar/softwares/rose_inst/include/DOTGenerationImpl.h \ + /homes/shanthar/softwares/rose_inst/include/sageInterface.h \ + /homes/shanthar/softwares/rose_inst/include/sage3.h \ + /homes/shanthar/softwares/rose_inst/include/attachPreprocessingInfo.h \ + /homes/shanthar/softwares/rose_inst/include/attachPreprocessingInfoTraversal.h \ + /homes/shanthar/softwares/rose_inst/include/attach_all_info.h \ + /homes/shanthar/softwares/rose_inst/include/astPostProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstFixup.h \ + /homes/shanthar/softwares/rose_inst/include/fixupforGnuBackendCompiler.h \ + /homes/shanthar/softwares/rose_inst/include/fixupFunctionDefinitions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupInClassDataInitialization.h \ + /homes/shanthar/softwares/rose_inst/include/fixupStorageAccessOfForwardTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/removeInitializedNamePtr.h \ + /homes/shanthar/softwares/rose_inst/include/AstNodePtrs.h \ + /usr/include/c++/4.4/iomanip \ + /homes/shanthar/softwares/rose_inst/include/fixupSourcePositionInformation.h \ + /homes/shanthar/softwares/rose_inst/include/fixupEnumValues.h \ + /homes/shanthar/softwares/rose_inst/include/fixupFriendTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupPrettyFunction.h \ + /homes/shanthar/softwares/rose_inst/include/resetParentPointers.h \ + /homes/shanthar/softwares/rose_inst/include/AstNodeVisitMapping.h \ + /homes/shanthar/softwares/rose_inst/include/processTemplateHandlingOptions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupSymbolTables.h \ + /homes/shanthar/softwares/rose_inst/include/markCompilerGenerated.h \ + /homes/shanthar/softwares/rose_inst/include/markTemplateInstantiationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/resetTemplateNames.h \ + /homes/shanthar/softwares/rose_inst/include/fixupDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTemplateInstantiations.h \ + /homes/shanthar/softwares/rose_inst/include/markForOutputInCodeGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/markTemplateSpecializationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/initializeExplicitScopeData.h \ + /homes/shanthar/softwares/rose_inst/include/fixupDefiningAndNondefiningDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/markOverloadedTemplateInstantiations.h \ + /homes/shanthar/softwares/rose_inst/include/markTransformationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/markBackendCompilerSpecificFunctions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupNullPointers.h \ + /homes/shanthar/softwares/rose_inst/include/checkIsModifiedFlag.h \ + /homes/shanthar/softwares/rose_inst/include/fixupNames.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTypes.h \ + /homes/shanthar/softwares/rose_inst/include/fixupConstructorPreinitializationLists.h \ + /homes/shanthar/softwares/rose_inst/include/propagateHiddenListData.h \ + /homes/shanthar/softwares/rose_inst/include/markLhsValues.h \ + /homes/shanthar/softwares/rose_inst/include/resolveFortranReferences.h \ + /homes/shanthar/softwares/rose_inst/include/insertFortranContainsStatement.h \ + /homes/shanthar/softwares/rose_inst/include/fixupUseAndUsingDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupCxxSymbolTablesToSupportAliasingSymbols.h \ + /homes/shanthar/softwares/rose_inst/include/normalizeTypedefSequenceLists.h \ + /homes/shanthar/softwares/rose_inst/include/fixupConstantFoldedValues.h \ + /homes/shanthar/softwares/rose_inst/include/fixupSelfReferentialMacros.h \ + /homes/shanthar/softwares/rose_inst/include/abstract_handle.h \ + /homes/shanthar/softwares/rose_inst/include/roseAdapter.h \ + /homes/shanthar/softwares/rose_inst/include/memory_object.h \ + /homes/shanthar/softwares/rose_inst/include/sageBuilder.h \ + /homes/shanthar/softwares/rose_inst/include/sageBuilderAsm.h \ + /homes/shanthar/softwares/rose_inst/include/omp_lowering.h \ + /homes/shanthar/softwares/rose_inst/include/astQuery.h \ + /homes/shanthar/softwares/rose_inst/include/astQueryInheritedAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/AstQueryMemoryPool.h \ + /homes/shanthar/softwares/rose_inst/include/astMergeAPI.h \ + /homes/shanthar/softwares/rose_inst/include/AstFromString.h \ + /homes/shanthar/softwares/rose_inst/include/rose.h \ + /homes/shanthar/softwares/rose_inst/include/ParserBuilder.hpp \ + /homes/shanthar/softwares/rose_inst/include/ParserBuilder.tpp \ + /homes/shanthar/softwares/rose_inst/include/rewrite.h \ + /homes/shanthar/softwares/rose_inst/include/AstReverseProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstReverseSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstClearVisitFlags.h \ + /homes/shanthar/softwares/rose_inst/include/transformationSupport.h \ + /homes/shanthar/softwares/rose_inst/include/optionDeclaration.h \ + /homes/shanthar/softwares/rose_inst/include/roseQueryLib.h \ + /homes/shanthar/softwares/rose_inst/include/booleanQuery.h \ + /homes/shanthar/softwares/rose_inst/include/nodeQuery.h \ + /homes/shanthar/softwares/rose_inst/include/nameQuery.h \ + /homes/shanthar/softwares/rose_inst/include/numberQuery.h \ + /homes/shanthar/softwares/rose_inst/include/lowLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/midLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/highLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/astUnparseAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/LivenessAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/filteredCFG.h \ + /homes/shanthar/softwares/rose_inst/include/filteredCFGImpl.h \ + /homes/shanthar/softwares/rose_inst/include/DefUseAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/DFAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/support.h \ + /homes/shanthar/softwares/rose_inst/include/DFAFilter.h \ + /homes/shanthar/softwares/rose_inst/include/DefUseAnalysisAbstract.h \ + /homes/shanthar/softwares/rose_inst/include/virtualCFG.h \ + /homes/shanthar/softwares/rose_inst/include/cfgToDot.h \ + /homes/shanthar/softwares/rose_inst/include/dfaToDot.h \ + /homes/shanthar/softwares/rose_inst/include/ClassHierarchyGraph.h \ + /homes/shanthar/softwares/rose_inst/include/manglingSupport.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_support.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_exprTree.h \ + /usr/include/i386-linux-gnu/sys/time.h \ + /homes/shanthar/softwares/rose_inst/include/x86InstructionProperties.h \ + /homes/shanthar/softwares/rose_inst/include/AstPerformance.h \ + /homes/shanthar/softwares/rose_inst/include/unparser.h \ + /homes/shanthar/softwares/rose_inst/include/unparser_opt.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_format.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFormatHelp.h \ + /homes/shanthar/softwares/rose_inst/include/unparseCxx_types.h \ + /homes/shanthar/softwares/rose_inst/include/name_qualification_support.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_sym.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_debug.h \ + /homes/shanthar/softwares/rose_inst/include/modified_sage.h \ + /homes/shanthar/softwares/rose_inst/include/unparseCxx.h \ + /homes/shanthar/softwares/rose_inst/include/unparseLanguageIndependentConstructs.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFortran.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFortran_types.h \ + /homes/shanthar/softwares/rose_inst/include/unparseJava.h \ + /homes/shanthar/softwares/rose_inst/include/unparsePHP.h \ + /homes/shanthar/softwares/rose_inst/include/unparsePython.h \ + /homes/shanthar/softwares/rose_inst/include/AstPDFGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstDiagnostics.h \ + /homes/shanthar/softwares/rose_inst/include/AstConsistencyTests.h \ + /homes/shanthar/softwares/rose_inst/include/AstStatistics.h \ + /homes/shanthar/softwares/rose_inst/include/AstTextAttributesHandling.h \ + /homes/shanthar/softwares/rose_inst/include/AstWarnings.h \ + /homes/shanthar/softwares/rose_inst/include/Ast.h \ + /homes/shanthar/softwares/rose_inst/include/wholeAST_API.h \ + /homes/shanthar/softwares/rose_inst/include/wholeAST.h \ + /homes/shanthar/softwares/rose_inst/include/copyGraph.h \ + /homes/shanthar/softwares/rose_inst/include/roseTranslators.h \ + /homes/shanthar/softwares/rose_inst/include/Translator.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstPDFGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstConsistencyTests.h \ + /homes/shanthar/softwares/rose_inst/include/merge.h \ + /homes/shanthar/softwares/rose_inst/include/test_support.h \ + /homes/shanthar/softwares/rose_inst/include/merge_support.h \ + /homes/shanthar/softwares/rose_inst/include/nullifyAST.h \ + /homes/shanthar/softwares/rose_inst/include/buildMangledNameMap.h \ + /homes/shanthar/softwares/rose_inst/include/deleteOrphanNodes.h \ + /homes/shanthar/softwares/rose_inst/include/buildReplacementMap.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTraversal.h \ + /homes/shanthar/softwares/rose_inst/include/collectAssociateNodes.h \ + /homes/shanthar/softwares/rose_inst/include/requiredNodes.h \ + /homes/shanthar/softwares/rose_inst/include/AST_FILE_IO.h \ + /homes/shanthar/softwares/rose_inst/include/AstSpecificDataManagingClass.h \ + /homes/shanthar/softwares/rose_inst/include/astGraph.h \ + /homes/shanthar/softwares/rose_inst/include/astGraphTemplateImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstAttributeDOT.h \ + /homes/shanthar/softwares/rose_inst/include/inliner.h \ + /homes/shanthar/softwares/rose_inst/include/replaceExpressionWithStatement.h \ + /homes/shanthar/softwares/rose_inst/include/inlinerSupport.h \ + /homes/shanthar/softwares/rose_inst/include/pre.h \ + /usr/include/c++/4.4/queue /usr/include/c++/4.4/bits/stl_queue.h \ + /homes/shanthar/softwares/rose_inst/include/expressionTreeEqual.h \ + /homes/shanthar/softwares/rose_inst/include/controlFlowGraph.h \ + /homes/shanthar/softwares/rose_inst/include/CFG.h \ + /homes/shanthar/softwares/rose_inst/include/AstInterface.h \ + /homes/shanthar/softwares/rose_inst/include/ObserveObject.h \ + /homes/shanthar/softwares/rose_inst/include/PtrSet.h \ + /homes/shanthar/softwares/rose_inst/include/FunctionObject.h \ + /homes/shanthar/softwares/rose_inst/include/PtrMap.h \ + /homes/shanthar/softwares/rose_inst/include/ProcessAstTree.h \ + /homes/shanthar/softwares/rose_inst/include/AstInterface.h \ + /homes/shanthar/softwares/rose_inst/include/SinglyLinkedList.h \ + /homes/shanthar/softwares/rose_inst/include/CommandOptions.h \ + /homes/shanthar/softwares/rose_inst/include/constantFolding.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList_Output.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList_Intersection.h \ + /homes/shanthar/softwares/rose_inst/include/cfgToDot.h \ + /homes/shanthar/softwares/rose_inst/include/MemoryMap.h \ + /homes/shanthar/softwares/boost_inst/include/boost/shared_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/shared_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/memory.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/shared_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/bad_weak_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/sp_typeinfo.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock_pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock_sync.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/yield_k.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/memory_order.hpp \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_abstract.h \ + /homes/shanthar/softwares/rose_inst/include/RoseFile.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_file.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_substTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_buildTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_buildTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_callGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_branchGraph.h \ + /usr/include/c++/4.4/cxxabi.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cxxabi_tweaks.h \ + /homes/shanthar/softwares/rose_inst/include/RoseObj.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DotGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_Graph.h \ + /homes/shanthar/softwares/rose_inst/include/SB_Graph.h \ + /homes/shanthar/softwares/rose_inst/include/MyAstAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_GmlGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_ControlFlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_FlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/GraphAlgorithms.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DataFlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DefUseAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DataFlowAbstract.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_Emulate.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_VariableAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_CallGraphAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/AST_BIN_Traversal.h \ + /homes/shanthar/softwares/rose_inst/include/AsmUnparser_compat.h \ + /homes/shanthar/softwares/rose_inst/include/AsmUnparser.h \ + /homes/shanthar/softwares/rose_inst/include/callbacks.h \ + /homes/shanthar/softwares/rose_inst/include/threadSupport.h \ + /homes/shanthar/softwares/rose_inst/include/BinaryControlFlow.h \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/adjacency_list.hpp \ + /usr/include/c++/4.4/ext/slist \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/tuple/tuple.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/ref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/tuple/detail/tuple_basic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/cv_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_cv.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/function_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/property.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/detail/property.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/same_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_mutability_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_selectors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/cstddef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept_archetype.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/vector_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/edge.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/properties.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/property_maps/constant_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/property_maps/null_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/named_graph.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index_container.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/allocator_utilities.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/no_exceptions_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/at.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/at_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/at_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin_end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin_end_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/begin_end_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/sequence_tag_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_begin.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/traits_lambda_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/sequence_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/is_msvc_eti_arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/advance.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/advance_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/less.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/comparison_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/numeric_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/numeric_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/numeric_cast_utils.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/forwarding.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_eti_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/less.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/negate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/long.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/long_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/advance_forward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/advance_backward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/deref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/contains.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/contains_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/contains_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/find.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/find_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/find_if_pred.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iter_fold_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/logical.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_fold_if_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/same_as.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/distance.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/distance_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iter_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/O1_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/O1_size_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/O1_size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_range.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index_container_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/identity_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/indexed_by.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/limits/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector20.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector10.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/at.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/typeof.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/push_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/item.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/pop_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pop_front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/push_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/pop_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pop_back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/clear.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/clear_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/vector0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_tags.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/plus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arithmetic_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/largest_int.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/minus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/O1_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/empty_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/begin_end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/include_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/expr_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/ordered_index_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/ord_index_args.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/no_duplicate_tags.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/set0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/at_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/has_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_key_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/overload_names.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/ptr_to_ref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/operators.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/clear_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/set0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/empty_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/insert_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/insert_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/item.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/erase_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/erase_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/erase_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/erase_key_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/key_type_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/key_type_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/value_type_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/value_type_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/begin_end_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_key.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/reverse_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/reverse_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pair_view.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_category.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/min_max.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/is_sequence.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/inserter_algorithm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/back_inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/push_back_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/front_inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/push_front_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/clear.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/clear_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/default_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/intercept.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_base_and_derived.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/access_specifier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/adl_swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/base_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/copy_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/auto_space.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/prevent_eti.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/node_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/reverse_iter_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/header_holder.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_node_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/archive_exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/decl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/abi_prefix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/abi_prefix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/abi_suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/abi_suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/access.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/pfto.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/is_index_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/empty_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/msvc_index_specifier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_loader.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/nvp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/level.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_fundamental.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/level_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/tracking.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/greater.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/tracking_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/type_info_implementation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/split_member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/base_object.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_polymorphic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/force_include.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/void_cast_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_saver.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_matcher.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/converter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/has_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/safe_mode.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/scope_guard.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/archive_constructed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/serialization.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/basic_archive.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/auto_link_archive.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/strong_typedef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/operators.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/serialization_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/comparison.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/not_equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/greater_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/collection_size_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/split_free.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/hashed_index.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/bucket_array.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_node.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/modify_key_adaptor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/safe_ctr_proxy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/hashed_index_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_args.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional/optional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/reference_content.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_copy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_copy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/none.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/none_t.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/compare_pointees.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional/optional_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/adjacency_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/integer_range.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/counting_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/numeric_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_new_operator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_assign.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_assign.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_constructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_constructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_virtual_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_signed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_unsigned.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_base_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_compound.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_floating_point.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_object_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_object.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_stateless.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_union.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_virtual_base_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/rank.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/extent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_bounds.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_extent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_all_extents.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/floating_point_promotion.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/integral_promotion.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/promote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/make_unsigned.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/make_signed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/decay.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_complex.hpp \ + /usr/include/c++/4.4/complex \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/select_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_concepts.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/numeric_values.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/container_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/adj_list_edge_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/adjacency_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/depth_first_search.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/visitors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/named_function_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/name.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/keyword.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/unwrap_cv_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/yesno.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/tagged_argument.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/arg_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/result_of0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/result_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_shifted_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/iter/forward1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/detail/shared.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/detail/result_of_iterate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/default.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/parameter_requirements.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/is_maybe.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/value_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/binding.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/shared_array_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/shared_array.hpp \ + /homes/shanthar/softwares/rose_inst/include/BinaryFunctionCall.h \ + /homes/shanthar/softwares/rose_inst/include/Disassembler.h \ + /homes/shanthar/softwares/rose_inst/include/Registers.h \ + /homes/shanthar/softwares/rose_inst/include/powerpcInstructionProperties.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerArm.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerPowerpc.h \ + /homes/shanthar/softwares/rose_inst/include/integerOps.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerX86.h \ + /homes/shanthar/softwares/rose_inst/include/Partitioner.h \ + /homes/shanthar/softwares/rose_inst/include/Assembler.h \ + /homes/shanthar/softwares/rose_inst/include/AssemblerX86.h \ + /homes/shanthar/softwares/rose_inst/include/abiStuff.h \ + /homes/shanthar/softwares/rose_inst/include/ether.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGenerationImpl.C \ + /homes/shanthar/softwares/rose_inst/include/utility_functionsImpl.C \ + ../include/code_gen/rose_attributes.h +CG_roseBuilder.o: ../src/CG_roseBuilder.cc /usr/include/c++/4.4/stack \ + /usr/include/c++/4.4/deque /usr/include/c++/4.4/bits/stl_algobase.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++config.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/os_defines.h \ + /usr/include/features.h /usr/include/i386-linux-gnu/bits/predefs.h \ + /usr/include/i386-linux-gnu/sys/cdefs.h \ + /usr/include/i386-linux-gnu/bits/wordsize.h \ + /usr/include/i386-linux-gnu/gnu/stubs.h \ + /usr/include/i386-linux-gnu/gnu/stubs-32.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cpu_defines.h \ + /usr/include/c++/4.4/cstddef \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stddef.h \ + /usr/include/c++/4.4/bits/functexcept.h \ + /usr/include/c++/4.4/exception_defines.h \ + /usr/include/c++/4.4/bits/cpp_type_traits.h \ + /usr/include/c++/4.4/ext/type_traits.h \ + /usr/include/c++/4.4/ext/numeric_traits.h \ + /usr/include/c++/4.4/bits/stl_pair.h /usr/include/c++/4.4/bits/move.h \ + /usr/include/c++/4.4/bits/concept_check.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_types.h \ + /usr/include/c++/4.4/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/4.4/bits/stl_iterator.h \ + /usr/include/c++/4.4/debug/debug.h /usr/include/c++/4.4/bits/allocator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++allocator.h \ + /usr/include/c++/4.4/ext/new_allocator.h /usr/include/c++/4.4/new \ + /usr/include/c++/4.4/exception /usr/include/c++/4.4/bits/stl_construct.h \ + /usr/include/c++/4.4/bits/stl_uninitialized.h \ + /usr/include/c++/4.4/bits/stl_deque.h \ + /usr/include/c++/4.4/initializer_list \ + /usr/include/c++/4.4/bits/deque.tcc \ + /usr/include/c++/4.4/bits/stl_stack.h \ + ../include/code_gen/CG_roseBuilder.h ../../basic/include/basic/Tuple.h \ + /usr/include/stdio.h /usr/include/i386-linux-gnu/bits/types.h \ + /usr/include/i386-linux-gnu/bits/typesizes.h /usr/include/libio.h \ + /usr/include/_G_config.h /usr/include/wchar.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include/stdarg.h \ + /usr/include/i386-linux-gnu/bits/stdio_lim.h \ + /usr/include/i386-linux-gnu/bits/sys_errlist.h \ + ../../basic/include/basic/Collection.h \ + ../../basic/include/basic/Iterator.h ../../basic/include/basic/util.h \ + /usr/include/stdlib.h /usr/include/i386-linux-gnu/bits/waitflags.h \ + /usr/include/i386-linux-gnu/bits/waitstatus.h /usr/include/endian.h \ + /usr/include/i386-linux-gnu/bits/endian.h \ + /usr/include/i386-linux-gnu/bits/byteswap.h /usr/include/xlocale.h \ + /usr/include/i386-linux-gnu/sys/types.h /usr/include/time.h \ + /usr/include/i386-linux-gnu/sys/select.h \ + /usr/include/i386-linux-gnu/bits/select.h \ + /usr/include/i386-linux-gnu/bits/sigset.h \ + /usr/include/i386-linux-gnu/bits/time.h \ + /usr/include/i386-linux-gnu/sys/sysmacros.h \ + /usr/include/i386-linux-gnu/bits/pthreadtypes.h /usr/include/alloca.h \ + /usr/include/assert.h /usr/include/c++/4.4/string \ + /usr/include/c++/4.4/bits/stringfwd.h \ + /usr/include/c++/4.4/bits/char_traits.h \ + /usr/include/c++/4.4/bits/postypes.h /usr/include/c++/4.4/cwchar \ + /usr/include/i386-linux-gnu/bits/wchar.h \ + /usr/include/c++/4.4/bits/localefwd.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++locale.h \ + /usr/include/c++/4.4/clocale /usr/include/locale.h \ + /usr/include/i386-linux-gnu/bits/locale.h /usr/include/c++/4.4/iosfwd \ + /usr/include/c++/4.4/cctype /usr/include/ctype.h \ + /usr/include/c++/4.4/bits/ostream_insert.h \ + /usr/include/c++/4.4/cxxabi-forced.h \ + /usr/include/c++/4.4/bits/stl_function.h \ + /usr/include/c++/4.4/backward/binders.h \ + /usr/include/c++/4.4/bits/basic_string.h \ + /usr/include/c++/4.4/ext/atomicity.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/i386-linux-gnu/bits/sched.h \ + /usr/include/i386-linux-gnu/bits/timex.h \ + /usr/include/i386-linux-gnu/bits/setjmp.h /usr/include/unistd.h \ + /usr/include/i386-linux-gnu/bits/posix_opt.h \ + /usr/include/i386-linux-gnu/bits/environments.h \ + /usr/include/i386-linux-gnu/bits/confname.h /usr/include/getopt.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/atomic_word.h \ + /usr/include/c++/4.4/bits/basic_string.tcc /usr/include/c++/4.4/sstream \ + /usr/include/c++/4.4/istream /usr/include/c++/4.4/ios \ + /usr/include/c++/4.4/bits/ios_base.h \ + /usr/include/c++/4.4/bits/locale_classes.h \ + /usr/include/c++/4.4/bits/locale_classes.tcc \ + /usr/include/c++/4.4/streambuf /usr/include/c++/4.4/bits/streambuf.tcc \ + /usr/include/c++/4.4/bits/basic_ios.h \ + /usr/include/c++/4.4/bits/locale_facets.h /usr/include/c++/4.4/cwctype \ + /usr/include/wctype.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_base.h \ + /usr/include/c++/4.4/bits/streambuf_iterator.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/ctype_inline.h \ + /usr/include/c++/4.4/bits/locale_facets.tcc \ + /usr/include/c++/4.4/bits/basic_ios.tcc /usr/include/c++/4.4/ostream \ + /usr/include/c++/4.4/bits/ostream.tcc \ + /usr/include/c++/4.4/bits/istream.tcc \ + /usr/include/c++/4.4/bits/sstream.tcc /usr/include/c++/4.4/stdexcept \ + ../../basic/include/basic/Tuple.c ../include/code_gen/rose_attributes.h \ + /homes/shanthar/softwares/rose_inst/include/rose.h \ + /homes/shanthar/softwares/rose_inst/include/rosePublicConfig.h \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.hhh \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.h \ + /usr/include/inttypes.h /usr/include/stdint.h /usr/include/semaphore.h \ + /usr/include/i386-linux-gnu/bits/semaphore.h \ + /homes/shanthar/softwares/rose_inst/include/fileoffsetbits.h \ + /homes/shanthar/softwares/rose_inst/include/rosedll.h \ + /homes/shanthar/softwares/rose_inst/include/rose_paths.h \ + /usr/include/i386-linux-gnu/sys/stat.h \ + /usr/include/i386-linux-gnu/bits/stat.h /usr/include/c++/4.4/algorithm \ + /usr/include/c++/4.4/bits/stl_algo.h /usr/include/c++/4.4/cstdlib \ + /usr/include/c++/4.4/bits/algorithmfwd.h \ + /usr/include/c++/4.4/bits/stl_heap.h \ + /usr/include/c++/4.4/bits/stl_tempbuf.h /usr/include/c++/4.4/fstream \ + /usr/include/c++/4.4/bits/codecvt.h /usr/include/c++/4.4/cstdio \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/basic_file.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/c++io.h \ + /usr/include/c++/4.4/bits/fstream.tcc \ + /homes/shanthar/softwares/rose_inst/include/rosedefs.h \ + /usr/include/c++/4.4/cassert /usr/include/c++/4.4/list \ + /usr/include/c++/4.4/bits/stl_list.h /usr/include/c++/4.4/bits/list.tcc \ + /usr/include/c++/4.4/vector /usr/include/c++/4.4/bits/stl_vector.h \ + /usr/include/c++/4.4/bits/stl_bvector.h \ + /usr/include/c++/4.4/bits/vector.tcc /usr/include/c++/4.4/set \ + /usr/include/c++/4.4/bits/stl_tree.h /usr/include/c++/4.4/bits/stl_set.h \ + /usr/include/c++/4.4/bits/stl_multiset.h /usr/include/c++/4.4/map \ + /usr/include/c++/4.4/bits/stl_map.h \ + /usr/include/c++/4.4/bits/stl_multimap.h \ + /homes/shanthar/softwares/rose_inst/include/roseInternal.h \ + /homes/shanthar/softwares/rose_inst/include/rose_msvc.h \ + /homes/shanthar/softwares/rose_inst/include/processSupport.h \ + /homes/shanthar/softwares/rose_inst/include/virtualCFG.h \ + /homes/shanthar/softwares/rose_inst/include/virtualBinCFG.h \ + /homes/shanthar/softwares/rose_inst/include/staticCFG.h \ + /homes/shanthar/softwares/rose_inst/include/sage3basic.h \ + /homes/shanthar/softwares/rose_inst/include/AstAttributeMechanism.h \ + /homes/shanthar/softwares/rose_inst/include/AttributeMechanism.h \ + /usr/include/c++/4.4/iostream \ + /homes/shanthar/softwares/rose_inst/include/rose_attributes_list.h \ + /homes/shanthar/softwares/rose_inst/include/general_token_defs.h \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/iterate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/dec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/config/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/inc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/data.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/array/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/cat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/slot.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/detail/def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_token.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/wave_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/user.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_compiler_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/compiler/gcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_stdlib_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/utility.hpp \ + /usr/include/c++/4.4/utility /usr/include/c++/4.4/bits/stl_relops.h \ + /homes/shanthar/softwares/boost_inst/include/boost/config/stdlib/libstdcpp3.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/select_platform_config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/platform/linux.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/posix_features.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/workaround.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/wave_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/flex_string.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/throw_exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/exception/detail/attribute_noreturn.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/exception/exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/current_function.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/reverse_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator.hpp \ + /usr/include/c++/4.4/iterator \ + /usr/include/c++/4.4/bits/stream_iterator.h \ + /homes/shanthar/softwares/boost_inst/include/boost/utility.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/addressof.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/base_from_member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_binary_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/punctuation/comma_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/iif.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/punctuation/comma.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/repeat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/debug/error.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/auto_rec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/eat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/rem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/repeat_from_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/add.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/while.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/detail/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/expr_iif.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/adt.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/is_binary.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/detail/check.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/compl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/fold_right.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/detail/fold_right.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/reverse.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/bitand.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/detail/while.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/sub.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/binary.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/deduce_d.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/cat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/fold_left.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/seq.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/elem.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/mod.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/arithmetic/detail/div_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/comparison/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/enable_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/checked_delete.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/next_prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/noncopyable.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_adaptor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/static_assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_categories.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/config_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/eval_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/value_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/static_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/workaround.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/integral.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/msvc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/eti.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/lambda_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/void_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/adl_barrier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/adl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/intel.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/gcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bool_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/static_constant.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/ctps.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/ttp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/int.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/int_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/nttp_decl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/nttp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/integral_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_arity_param.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/template_arity_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/dtp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/preprocessor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/comma_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repeat.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/inc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/limits/arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/logical/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/overload_resolution.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/placeholders.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/arg_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/na_assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/nested_type_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/yes_no.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/arrays.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/pp_counter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arity_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arg_typedef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/use_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/include_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/compiler.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/stringize.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_convertible.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/intrinsics.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_same.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/bool_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/template_arity_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/integral_constant.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/integral_c_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/bool_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_lvalue_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_rvalue_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/ice.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/yes_no_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_not.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/ice_eq.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/cv_traits_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_array.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/type_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/type_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_arithmetic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_integral.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_float.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_abstract.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/config_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_facade.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/interoperable.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/or.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/iterator_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/facade_iterator_category.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/and.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/indirect_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_function.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/false_result.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/is_function_ptr_helper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_function_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_cv.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/broken_compiler_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_class.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/detail/enable_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/implicit_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_const.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_pod.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_scalar.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/always.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/apply_wrap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_xxx.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/type_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/has_xxx.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/msvc_typename.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_trailing_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/has_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_never_true.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/bind_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/next.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/next_prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/common_name_wknd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/protect.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/full_lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/quote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/bcc.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/template_arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp \ + /usr/include/c++/4.4/memory \ + /usr/include/c++/4.4/bits/stl_raw_storage_iter.h \ + /usr/include/c++/4.4/backward/auto_ptr.h /usr/include/c++/4.4/functional \ + /usr/include/c++/4.4/limits /usr/include/c++/4.4/cstring \ + /usr/include/string.h \ + /homes/shanthar/softwares/boost_inst/include/boost/config/auto_link.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/file_position.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_position_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/position_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept_check.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/general.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/backward_compatibility.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/has_constraints.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/conversion_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/usage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/concept_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/for_each_i.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/for.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/detail/for.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/seq/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept/detail/concept_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/namespace.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/position_iterator_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/core/nil.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/impl/position_iterator.ipp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator_adaptors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/token_ids.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/language_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/singleton_pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/poolfwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/mutex.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/ct_gcd_lcm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/gcd_lcm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/simple_segregated_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/singleton.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pool/detail/guard.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/atomic_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/atomic_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_has_sync.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/intrusive_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/intrusive_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_convertible.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/functional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/operator_bool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/support_multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/first_owner_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/multi_pass_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/multi_pass_wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/detail/scoped_enum_emulation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/scoped_enum_emulation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/ref_counted_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/input_iterator_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/buffering_input_iterator_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/istream_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/lex_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/split_functor_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/functor_input_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/buf_id_check_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/no_check_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/fixed_size_queue_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/fixed_size_queue.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/split_std_deque_policy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/detail/combine_policies.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/support/iterators/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/limits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/util/functor_input.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/include/classic_multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/multi_pass.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/core/assert.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/fixed_size_queue.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/spirit/home/classic/iterator/multi_pass_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_interface_generator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/wave/cpplexer/cpp_lex_interface.hpp \ + /homes/shanthar/softwares/rose_inst/include/string_functions.h \ + /homes/shanthar/softwares/rose_inst/include/commandline_processing.h \ + /homes/shanthar/softwares/rose_inst/include/setup.h \ + /homes/shanthar/softwares/rose_inst/include/escape.h \ + /homes/shanthar/softwares/rose_inst/include/sla.h \ + /homes/shanthar/softwares/rose_inst/include/Cxx_Grammar.h \ + /homes/shanthar/softwares/rose_inst/include/rangemap.h \ + /usr/include/c++/4.4/cmath /usr/include/math.h \ + /usr/include/i386-linux-gnu/bits/huge_val.h \ + /usr/include/i386-linux-gnu/bits/huge_valf.h \ + /usr/include/i386-linux-gnu/bits/huge_vall.h \ + /usr/include/i386-linux-gnu/bits/inf.h \ + /usr/include/i386-linux-gnu/bits/nan.h \ + /usr/include/i386-linux-gnu/bits/mathdef.h \ + /usr/include/i386-linux-gnu/bits/mathcalls.h \ + /usr/include/c++/4.4/bits/cmath.tcc \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_map_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/hash_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/hash.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/hash_float.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/float_functions.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/cmath.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/limits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer/static_log2.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer_fwd.hpp \ + /usr/include/c++/4.4/climits \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/limits.h \ + /usr/lib/gcc/i686-linux-gnu/4.4.7/include-fixed/syslimits.h \ + /usr/include/limits.h /usr/include/i386-linux-gnu/bits/posix1_lim.h \ + /usr/include/i386-linux-gnu/bits/local_lim.h /usr/include/linux/limits.h \ + /usr/include/i386-linux-gnu/bits/posix2_lim.h \ + /usr/include/i386-linux-gnu/bits/xopen_lim.h \ + /homes/shanthar/softwares/boost_inst/include/boost/cstdint.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/detail/hash_float_generic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/functional/hash/extensions.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/container_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/allocator_helpers.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/equivalent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/table.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/buckets.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/node.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/compressed_pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/compressed_pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/call_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/call_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/aligned_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/aligned_storage.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/alignment_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/size_t_trait_def.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_t.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_t_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/detail/size_t_trait_undef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/type_with_alignment.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/for_each_i.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/tuple/to_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/list/append.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/util.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/extract_key.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/unique.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/detail/move.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered_set.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_set.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/unordered/unordered_set_fwd.hpp \ + /homes/shanthar/softwares/rose_inst/include/Cxx_Grammar.h \ + /homes/shanthar/softwares/rose_inst/include/InstructionEnumsX86.h \ + /homes/shanthar/softwares/rose_inst/include/AssemblerX86Init.h \ + /homes/shanthar/softwares/rose_inst/include/armInstructionEnum.h \ + /homes/shanthar/softwares/rose_inst/include/powerpcInstructionEnum.h \ + /homes/shanthar/softwares/rose_inst/include/DataConversion.h \ + /homes/shanthar/softwares/rose_inst/include/utility_functions.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/DOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSuccessorsSelectors.h \ + /homes/shanthar/softwares/rose_inst/include/StackFrameVector.h \ + /homes/shanthar/softwares/rose_inst/include/Cxx_GrammarTreeTraversalAccessEnums.h \ + /homes/shanthar/softwares/rose_inst/include/AstSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedProcessingImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstCombinedSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelProcessingImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstSharedMemoryParallelSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/DOTRepresentation.h \ + /homes/shanthar/softwares/rose_inst/include/DOTRepresentationImpl.h \ + /usr/include/c++/4.4/typeinfo \ + /homes/shanthar/softwares/rose_inst/include/DOTGenerationImpl.h \ + /homes/shanthar/softwares/rose_inst/include/sageInterface.h \ + /homes/shanthar/softwares/rose_inst/include/sage3.h \ + /homes/shanthar/softwares/rose_inst/include/attachPreprocessingInfo.h \ + /homes/shanthar/softwares/rose_inst/include/attachPreprocessingInfoTraversal.h \ + /homes/shanthar/softwares/rose_inst/include/attach_all_info.h \ + /homes/shanthar/softwares/rose_inst/include/astPostProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstFixup.h \ + /homes/shanthar/softwares/rose_inst/include/fixupforGnuBackendCompiler.h \ + /homes/shanthar/softwares/rose_inst/include/fixupFunctionDefinitions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupInClassDataInitialization.h \ + /homes/shanthar/softwares/rose_inst/include/fixupStorageAccessOfForwardTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/removeInitializedNamePtr.h \ + /homes/shanthar/softwares/rose_inst/include/AstNodePtrs.h \ + /usr/include/c++/4.4/iomanip \ + /homes/shanthar/softwares/rose_inst/include/fixupSourcePositionInformation.h \ + /homes/shanthar/softwares/rose_inst/include/fixupEnumValues.h \ + /homes/shanthar/softwares/rose_inst/include/fixupFriendTemplateDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupPrettyFunction.h \ + /homes/shanthar/softwares/rose_inst/include/resetParentPointers.h \ + /homes/shanthar/softwares/rose_inst/include/AstNodeVisitMapping.h \ + /homes/shanthar/softwares/rose_inst/include/processTemplateHandlingOptions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupSymbolTables.h \ + /homes/shanthar/softwares/rose_inst/include/markCompilerGenerated.h \ + /homes/shanthar/softwares/rose_inst/include/markTemplateInstantiationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/resetTemplateNames.h \ + /homes/shanthar/softwares/rose_inst/include/fixupDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTemplateInstantiations.h \ + /homes/shanthar/softwares/rose_inst/include/markForOutputInCodeGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/markTemplateSpecializationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/initializeExplicitScopeData.h \ + /homes/shanthar/softwares/rose_inst/include/fixupDefiningAndNondefiningDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/markOverloadedTemplateInstantiations.h \ + /homes/shanthar/softwares/rose_inst/include/markTransformationsForOutput.h \ + /homes/shanthar/softwares/rose_inst/include/markBackendCompilerSpecificFunctions.h \ + /homes/shanthar/softwares/rose_inst/include/fixupNullPointers.h \ + /homes/shanthar/softwares/rose_inst/include/checkIsModifiedFlag.h \ + /homes/shanthar/softwares/rose_inst/include/fixupNames.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTypes.h \ + /homes/shanthar/softwares/rose_inst/include/fixupConstructorPreinitializationLists.h \ + /homes/shanthar/softwares/rose_inst/include/propagateHiddenListData.h \ + /homes/shanthar/softwares/rose_inst/include/markLhsValues.h \ + /homes/shanthar/softwares/rose_inst/include/resolveFortranReferences.h \ + /homes/shanthar/softwares/rose_inst/include/insertFortranContainsStatement.h \ + /homes/shanthar/softwares/rose_inst/include/fixupUseAndUsingDeclarations.h \ + /homes/shanthar/softwares/rose_inst/include/fixupCxxSymbolTablesToSupportAliasingSymbols.h \ + /homes/shanthar/softwares/rose_inst/include/normalizeTypedefSequenceLists.h \ + /homes/shanthar/softwares/rose_inst/include/fixupConstantFoldedValues.h \ + /homes/shanthar/softwares/rose_inst/include/fixupSelfReferentialMacros.h \ + /homes/shanthar/softwares/rose_inst/include/abstract_handle.h \ + /homes/shanthar/softwares/rose_inst/include/roseAdapter.h \ + /homes/shanthar/softwares/rose_inst/include/memory_object.h \ + /homes/shanthar/softwares/rose_inst/include/sageBuilder.h \ + /homes/shanthar/softwares/rose_inst/include/sageBuilderAsm.h \ + /homes/shanthar/softwares/rose_inst/include/omp_lowering.h \ + /homes/shanthar/softwares/rose_inst/include/astQuery.h \ + /homes/shanthar/softwares/rose_inst/include/astQueryInheritedAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/AstQueryMemoryPool.h \ + /homes/shanthar/softwares/rose_inst/include/astMergeAPI.h \ + /homes/shanthar/softwares/rose_inst/include/AstFromString.h \ + /homes/shanthar/softwares/rose_inst/include/rose.h \ + /homes/shanthar/softwares/rose_inst/include/ParserBuilder.hpp \ + /homes/shanthar/softwares/rose_inst/include/ParserBuilder.tpp \ + /homes/shanthar/softwares/rose_inst/include/rewrite.h \ + /homes/shanthar/softwares/rose_inst/include/AstReverseProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstReverseSimpleProcessing.h \ + /homes/shanthar/softwares/rose_inst/include/AstClearVisitFlags.h \ + /homes/shanthar/softwares/rose_inst/include/transformationSupport.h \ + /homes/shanthar/softwares/rose_inst/include/optionDeclaration.h \ + /homes/shanthar/softwares/rose_inst/include/roseQueryLib.h \ + /homes/shanthar/softwares/rose_inst/include/booleanQuery.h \ + /homes/shanthar/softwares/rose_inst/include/nodeQuery.h \ + /homes/shanthar/softwares/rose_inst/include/nameQuery.h \ + /homes/shanthar/softwares/rose_inst/include/numberQuery.h \ + /homes/shanthar/softwares/rose_inst/include/lowLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/midLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/highLevelRewriteInterface.h \ + /homes/shanthar/softwares/rose_inst/include/astUnparseAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/LivenessAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/filteredCFG.h \ + /homes/shanthar/softwares/rose_inst/include/filteredCFGImpl.h \ + /homes/shanthar/softwares/rose_inst/include/DefUseAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/DFAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/support.h \ + /homes/shanthar/softwares/rose_inst/include/DFAFilter.h \ + /homes/shanthar/softwares/rose_inst/include/DefUseAnalysisAbstract.h \ + /homes/shanthar/softwares/rose_inst/include/virtualCFG.h \ + /homes/shanthar/softwares/rose_inst/include/cfgToDot.h \ + /homes/shanthar/softwares/rose_inst/include/dfaToDot.h \ + /homes/shanthar/softwares/rose_inst/include/ClassHierarchyGraph.h \ + /homes/shanthar/softwares/rose_inst/include/manglingSupport.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_support.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_exprTree.h \ + /usr/include/i386-linux-gnu/sys/time.h \ + /homes/shanthar/softwares/rose_inst/include/x86InstructionProperties.h \ + /homes/shanthar/softwares/rose_inst/include/AstPerformance.h \ + /homes/shanthar/softwares/rose_inst/include/unparser.h \ + /homes/shanthar/softwares/rose_inst/include/unparser_opt.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_format.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFormatHelp.h \ + /homes/shanthar/softwares/rose_inst/include/unparseCxx_types.h \ + /homes/shanthar/softwares/rose_inst/include/name_qualification_support.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_sym.h \ + /homes/shanthar/softwares/rose_inst/include/unparse_debug.h \ + /homes/shanthar/softwares/rose_inst/include/modified_sage.h \ + /homes/shanthar/softwares/rose_inst/include/unparseCxx.h \ + /homes/shanthar/softwares/rose_inst/include/unparseLanguageIndependentConstructs.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFortran.h \ + /homes/shanthar/softwares/rose_inst/include/unparseFortran_types.h \ + /homes/shanthar/softwares/rose_inst/include/unparseJava.h \ + /homes/shanthar/softwares/rose_inst/include/unparsePHP.h \ + /homes/shanthar/softwares/rose_inst/include/unparsePython.h \ + /homes/shanthar/softwares/rose_inst/include/AstPDFGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstDiagnostics.h \ + /homes/shanthar/softwares/rose_inst/include/AstConsistencyTests.h \ + /homes/shanthar/softwares/rose_inst/include/AstStatistics.h \ + /homes/shanthar/softwares/rose_inst/include/AstTextAttributesHandling.h \ + /homes/shanthar/softwares/rose_inst/include/AstWarnings.h \ + /homes/shanthar/softwares/rose_inst/include/Ast.h \ + /homes/shanthar/softwares/rose_inst/include/wholeAST_API.h \ + /homes/shanthar/softwares/rose_inst/include/wholeAST.h \ + /homes/shanthar/softwares/rose_inst/include/copyGraph.h \ + /homes/shanthar/softwares/rose_inst/include/roseTranslators.h \ + /homes/shanthar/softwares/rose_inst/include/Translator.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstPDFGeneration.h \ + /homes/shanthar/softwares/rose_inst/include/AstConsistencyTests.h \ + /homes/shanthar/softwares/rose_inst/include/merge.h \ + /homes/shanthar/softwares/rose_inst/include/test_support.h \ + /homes/shanthar/softwares/rose_inst/include/merge_support.h \ + /homes/shanthar/softwares/rose_inst/include/nullifyAST.h \ + /homes/shanthar/softwares/rose_inst/include/buildMangledNameMap.h \ + /homes/shanthar/softwares/rose_inst/include/deleteOrphanNodes.h \ + /homes/shanthar/softwares/rose_inst/include/buildReplacementMap.h \ + /homes/shanthar/softwares/rose_inst/include/fixupTraversal.h \ + /homes/shanthar/softwares/rose_inst/include/collectAssociateNodes.h \ + /homes/shanthar/softwares/rose_inst/include/requiredNodes.h \ + /homes/shanthar/softwares/rose_inst/include/AST_FILE_IO.h \ + /homes/shanthar/softwares/rose_inst/include/AstSpecificDataManagingClass.h \ + /homes/shanthar/softwares/rose_inst/include/astGraph.h \ + /homes/shanthar/softwares/rose_inst/include/astGraphTemplateImpl.h \ + /homes/shanthar/softwares/rose_inst/include/AstAttributeDOT.h \ + /homes/shanthar/softwares/rose_inst/include/inliner.h \ + /homes/shanthar/softwares/rose_inst/include/replaceExpressionWithStatement.h \ + /homes/shanthar/softwares/rose_inst/include/inlinerSupport.h \ + /homes/shanthar/softwares/rose_inst/include/pre.h \ + /usr/include/c++/4.4/queue /usr/include/c++/4.4/bits/stl_queue.h \ + /homes/shanthar/softwares/rose_inst/include/expressionTreeEqual.h \ + /homes/shanthar/softwares/rose_inst/include/controlFlowGraph.h \ + /homes/shanthar/softwares/rose_inst/include/CFG.h \ + /homes/shanthar/softwares/rose_inst/include/AstInterface.h \ + /homes/shanthar/softwares/rose_inst/include/ObserveObject.h \ + /homes/shanthar/softwares/rose_inst/include/PtrSet.h \ + /homes/shanthar/softwares/rose_inst/include/FunctionObject.h \ + /homes/shanthar/softwares/rose_inst/include/PtrMap.h \ + /homes/shanthar/softwares/rose_inst/include/ProcessAstTree.h \ + /homes/shanthar/softwares/rose_inst/include/AstInterface.h \ + /homes/shanthar/softwares/rose_inst/include/SinglyLinkedList.h \ + /homes/shanthar/softwares/rose_inst/include/CommandOptions.h \ + /homes/shanthar/softwares/rose_inst/include/constantFolding.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList_Output.h \ + /homes/shanthar/softwares/rose_inst/include/HiddenList_Intersection.h \ + /homes/shanthar/softwares/rose_inst/include/cfgToDot.h \ + /homes/shanthar/softwares/rose_inst/include/MemoryMap.h \ + /homes/shanthar/softwares/boost_inst/include/boost/shared_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/shared_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/no_tr1/memory.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/shared_count.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/bad_weak_ptr.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/sp_typeinfo.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/sp_counted_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock_pool.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/spinlock_sync.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/detail/yield_k.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/memory_order.hpp \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_abstract.h \ + /homes/shanthar/softwares/rose_inst/include/RoseFile.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_file.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_substTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_buildTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_buildTree.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_callGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_IDAPRO_branchGraph.h \ + /usr/include/c++/4.4/cxxabi.h \ + /usr/include/c++/4.4/i686-linux-gnu/./bits/cxxabi_tweaks.h \ + /homes/shanthar/softwares/rose_inst/include/RoseObj.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DotGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_Graph.h \ + /homes/shanthar/softwares/rose_inst/include/SB_Graph.h \ + /homes/shanthar/softwares/rose_inst/include/MyAstAttribute.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_GmlGraph.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_ControlFlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_FlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/GraphAlgorithms.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DataFlowAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DefUseAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_DataFlowAbstract.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_Emulate.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_VariableAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/RoseBin_CallGraphAnalysis.h \ + /homes/shanthar/softwares/rose_inst/include/AST_BIN_Traversal.h \ + /homes/shanthar/softwares/rose_inst/include/AsmUnparser_compat.h \ + /homes/shanthar/softwares/rose_inst/include/AsmUnparser.h \ + /homes/shanthar/softwares/rose_inst/include/callbacks.h \ + /homes/shanthar/softwares/rose_inst/include/threadSupport.h \ + /homes/shanthar/softwares/rose_inst/include/BinaryControlFlow.h \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/adjacency_list.hpp \ + /usr/include/c++/4.4/ext/slist \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/tuple/tuple.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/ref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/tuple/detail/tuple_basic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/cv_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/add_cv.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_volatile.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/function_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/property.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/detail/property.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/same_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_mutability_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_selectors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/cstddef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/concept_archetype.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/vector_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/edge.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/properties.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/property_maps/constant_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/property_maps/null_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/named_graph.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index_container.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/allocator_utilities.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/no_exceptions_support.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/at.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/at_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/at_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin_end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin_end_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/begin_end_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/sequence_tag_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_begin.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/traits_lambda_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/sequence_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/is_msvc_eti_arg.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/advance.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/advance_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/less.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/comparison_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/numeric_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/numeric_cast.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/numeric_cast_utils.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/forwarding.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_eti_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/less.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/negate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/long.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/long_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/advance_forward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/advance_backward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/prior.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/deref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/msvc_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/contains.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/contains_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/contains_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/find.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/find_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/find_if_pred.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_apply.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iter_fold_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/logical.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pair.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_fold_if_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/same_as.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/lambda_spec.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/size_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/distance.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/distance_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iter_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/O1_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/O1_size_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/O1_size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_range.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index_container_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/identity.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/identity_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/indexed_by.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/limits/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector20.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector10.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/vector0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/at.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/typeof.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/push_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/item.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/pop_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pop_front_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/push_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/pop_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pop_back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/back_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/clear.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/clear_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/vector0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_tags.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/plus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/arithmetic_op.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/largest_int.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/minus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/O1_size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/size.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/empty_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/begin_end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/include_preprocessed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/control/expr_if.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/ordered_index_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/ord_index_args.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/no_duplicate_tags.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/set0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/at_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/has_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_key_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/overload_names.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/ptr_to_ref.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/config/operators.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/clear_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/set0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/size_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/empty_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/insert_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/insert_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/item.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/erase_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/erase_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/erase_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/erase_key_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/key_type_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/key_type_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/value_type_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/value_type_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/begin_end_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/set/aux_/iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/has_key.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/has_key_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/transform.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/reverse_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/reverse_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/pair_view.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/iterator_category.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/min_max.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/is_sequence.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/inserter_algorithm.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/back_inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_back.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/push_back_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/front_inserter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/push_front.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/push_front_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/clear.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/clear_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessor/default_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/facilities/intercept.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_base_and_derived.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/access_specifier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/adl_swap.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/base_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/copy_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/auto_space.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/prevent_eti.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/node_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/reverse_iter_fold.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/header_holder.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_node_base.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/archive_exception.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/decl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/abi_prefix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/abi_prefix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/abi_suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/config/abi_suffix.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/access.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/pfto.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/is_index_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/empty.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/empty_impl.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/msvc_index_specifier.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_loader.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/nvp.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/level.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_fundamental.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/level_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/tracking.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/greater.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/tracking_enum.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/type_info_implementation.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/split_member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/base_object.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_polymorphic.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/force_include.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/void_cast_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/wrapper.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_saver.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/index_matcher.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/converter.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/has_tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/safe_mode.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/scope_guard.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/archive_constructed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/serialization.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/basic_archive.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/integer_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/archive/detail/auto_link_archive.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/strong_typedef.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/operators.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/serialization_version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/version.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/comparison.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/not_equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/greater_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/collection_size_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/serialization/split_free.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/hashed_index.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/bucket_array.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_node.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/modify_key_adaptor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/safe_ctr_proxy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/hashed_index_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/detail/hash_index_args.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/multi_index/member.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional/optional.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/reference_content.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_copy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_copy.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/none.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/none_t.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/compare_pointees.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/optional/optional_fwd.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/adjacency_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/integer_range.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/iterator/counting_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/numeric_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_new_operator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_assign.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_assign.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_constructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_constructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_nothrow_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_trivial_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/has_virtual_destructor.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_signed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_unsigned.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_base_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_compound.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_floating_point.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_member_object_pointer.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_object.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_stateless.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_union.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_virtual_base_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/rank.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/extent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_bounds.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_extent.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/remove_all_extents.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/floating_point_promotion.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/integral_promotion.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/promote.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/make_unsigned.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/make_signed.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/decay.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/type_traits/is_complex.hpp \ + /usr/include/c++/4.4/complex \ + /homes/shanthar/softwares/boost_inst/include/boost/detail/select_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/graph_concepts.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/numeric_values.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/pending/container_traits.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/detail/adj_list_edge_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/adjacency_iterator.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/depth_first_search.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/visitors.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/graph/named_function_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/name.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/keyword.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/unwrap_cv_reference.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/yesno.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/tag.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/tagged_argument.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/void.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/arg_list.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/result_of0.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/result_of.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/repetition/enum_shifted_params.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/iter/forward1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/slot/detail/shared.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/utility/detail/result_of_iterate.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/default.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/parameter_requirements.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/aux_/is_maybe.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/config.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/begin.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/mpl/end.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/value_type.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/parameter/binding.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/property_map/shared_array_property_map.hpp \ + /homes/shanthar/softwares/boost_inst/include/boost/smart_ptr/shared_array.hpp \ + /homes/shanthar/softwares/rose_inst/include/BinaryFunctionCall.h \ + /homes/shanthar/softwares/rose_inst/include/Disassembler.h \ + /homes/shanthar/softwares/rose_inst/include/Registers.h \ + /homes/shanthar/softwares/rose_inst/include/powerpcInstructionProperties.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerArm.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerPowerpc.h \ + /homes/shanthar/softwares/rose_inst/include/integerOps.h \ + /homes/shanthar/softwares/rose_inst/include/DisassemblerX86.h \ + /homes/shanthar/softwares/rose_inst/include/Partitioner.h \ + /homes/shanthar/softwares/rose_inst/include/Assembler.h \ + /homes/shanthar/softwares/rose_inst/include/AssemblerX86.h \ + /homes/shanthar/softwares/rose_inst/include/abiStuff.h \ + /homes/shanthar/softwares/rose_inst/include/ether.h \ + /homes/shanthar/softwares/rose_inst/include/AstDOTGenerationImpl.C \ + /homes/shanthar/softwares/rose_inst/include/utility_functionsImpl.C \ + ../include/code_gen/CG_outputBuilder.h \ + ../include/code_gen/CG_outputRepr.h ../include/code_gen/CG_roseRepr.h diff --git a/omega/code_gen/src/CG.cc b/omega/code_gen/src/CG.cc new file mode 100644 index 0000000..42bd172 --- /dev/null +++ b/omega/code_gen/src/CG.cc @@ -0,0 +1,1163 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + CG node classes, used to build AST tree from polyhedra scanning. + + Notes: + Parameter "restriction" is always tighter than "known" since CG_split + node does not correspond to any code for enforcement. This property is + destroyed after hoistGuard since "restriction" is not used anymore. + CG node's children are guaranteed not to be NULL, either NULL child is + removed from the children or the parent node itself becomes NULL. + + History: + 04/20/96 printRepr added by D people. Lei Zhou + 10/24/06 hoistGuard added by chun + 08/03/10 collect CG classes into one place, by Chun Chen + 08/04/10 track dynamically substituted variables in printRepr, by chun + 04/02/11 rewrite the CG node classes, by chun + *****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace omega { + +extern std::vector > smtNonSplitLevels; +extern std::vector > loopIdxNames; //per stmt +extern std::vector > syncs; + +extern int checkLoopLevel; +extern int stmtForLoopCheck; +extern int upperBoundForLevel; +extern int lowerBoundForLevel; +extern bool fillInBounds; + +//----------------------------------------------------------------------------- +// Class: CG_result +//----------------------------------------------------------------------------- + +CG_outputRepr *CG_result::printRepr(CG_outputBuilder *ocg, + const std::vector &stmts) const { + return printRepr(1, ocg, stmts, + std::vector >(num_level(), + std::make_pair(static_cast(NULL), 0))); +} + +std::string CG_result::printString() const { + CG_stringBuilder ocg; + std::vector stmts(codegen_->xforms_.size()); + for (int i = 0; i < stmts.size(); i++) + stmts[i] = new CG_stringRepr("s" + to_string(i)); + CG_stringRepr *repr = static_cast(printRepr(&ocg, stmts)); + for (int i = 0; i < stmts.size(); i++) + delete stmts[i]; + + if (repr != NULL) { + std::string s = repr->GetString(); + delete repr; + return s; + } else + return std::string(); +} + +int CG_result::num_level() const { + return codegen_->num_level(); +} + +//----------------------------------------------------------------------------- +// Class: CG_split +//----------------------------------------------------------------------------- + +CG_result *CG_split::recompute(const BoolSet<> &parent_active, + const Relation &known, const Relation &restriction) { + active_ &= parent_active; + if (active_.empty()) { + delete this; + return NULL; + } + + + int i = 0; + while (i < restrictions_.size()) { + Relation new_restriction = Intersection(copy(restrictions_[i]), + copy(restriction)); + + new_restriction.simplify(2, 4); + //new_restriction.simplify(); + clauses_[i] = clauses_[i]->recompute(active_, copy(known), + new_restriction); + if (clauses_[i] == NULL) { + restrictions_.erase(restrictions_.begin() + i); + clauses_.erase(clauses_.begin() + i); + } else + i++; + } + + + if (restrictions_.size() == 0) { + delete this; + return NULL; + } else + return this; +} + +int CG_split::populateDepth() { + int max_depth = 0; + for (int i = 0; i < clauses_.size(); i++) { + int t = clauses_[i]->populateDepth(); + if (t > max_depth) + max_depth = t; + } + return max_depth; +} + +std::pair CG_split::liftOverhead(int depth, + bool propagate_up) { + for (int i = 0; i < clauses_.size();) { + std::pair result = clauses_[i]->liftOverhead( + depth, propagate_up); + if (result.first == NULL) + clauses_.erase(clauses_.begin() + i); + else { + clauses_[i] = result.first; + if (!result.second.is_obvious_tautology()) + return std::make_pair(this, result.second); + i++; + } + + } + + if (clauses_.size() == 0) { + delete this; + return std::make_pair(static_cast(NULL), + Relation::True(num_level())); + } else + return std::make_pair(this, Relation::True(num_level())); +} + +Relation CG_split::hoistGuard() { + std::vector guards; + for (int i = 0; i < clauses_.size(); i++) + guards.push_back(clauses_[i]->hoistGuard()); + + return SimpleHull(guards, true, true); +} + +void CG_split::removeGuard(const Relation &guard) { + for (int i = 0; i < clauses_.size(); i++) + clauses_[i]->removeGuard(guard); +} + +std::vector CG_split::findNextLevel() const { + std::vector result; + for (int i = 0; i < clauses_.size(); i++) { + CG_split *splt = dynamic_cast(clauses_[i]); + if (splt != NULL) { + std::vector t = splt->findNextLevel(); + result.insert(result.end(), t.begin(), t.end()); + } else + result.push_back(clauses_[i]); + } + + return result; +} + +CG_outputRepr *CG_split::printRepr(int indent, CG_outputBuilder *ocg, + const std::vector &stmts, + const std::vector > &assigned_on_the_fly) const { + CG_outputRepr *stmtList = NULL; + std::vector next_level = findNextLevel(); + + std::vector cur_loops; + for (int i = 0; i < next_level.size(); i++) { + CG_loop *lp = dynamic_cast(next_level[i]); + if (lp != NULL) { + cur_loops.push_back(lp); + } else { + stmtList = ocg->StmtListAppend(stmtList, + loop_print_repr(cur_loops, 0, cur_loops.size(), + Relation::True(num_level()), NULL, indent, ocg, + stmts, assigned_on_the_fly)); + stmtList = ocg->StmtListAppend(stmtList, + next_level[i]->printRepr(indent, ocg, stmts, + assigned_on_the_fly)); + cur_loops.clear(); + } + } + + stmtList = ocg->StmtListAppend(stmtList, + loop_print_repr(cur_loops, 0, cur_loops.size(), + Relation::True(num_level()), NULL, indent, ocg, stmts, + assigned_on_the_fly)); + return stmtList; +} + +CG_result *CG_split::clone() const { + std::vector clauses(clauses_.size()); + for (int i = 0; i < clauses_.size(); i++) + clauses[i] = clauses_[i]->clone(); + return new CG_split(codegen_, active_, restrictions_, clauses); +} + +void CG_split::dump(int indent) const { + std::string prefix; + for (int i = 0; i < indent; i++) + prefix += " "; + std::cout << prefix << "SPLIT: " << active_ << std::endl; + for (int i = 0; i < restrictions_.size(); i++) { + std::cout << prefix << "restriction: "; + const_cast(this)->restrictions_[i].print(); + clauses_[i]->dump(indent + 1); + } + +} + +//----------------------------------------------------------------------------- +// Class: CG_loop +//----------------------------------------------------------------------------- + +CG_result *CG_loop::recompute(const BoolSet<> &parent_active, + const Relation &known, const Relation &restriction) { + known_ = copy(known); + restriction_ = copy(restriction); + active_ &= parent_active; + + std::vector Rs; + for (BoolSet<>::iterator i = active_.begin(); i != active_.end(); i++) { + Relation r = Intersection(copy(restriction), + copy(codegen_->projected_IS_[level_ - 1][*i])); + + //r.simplify(2, 4); + r.simplify(); + if (!r.is_upper_bound_satisfiable()) { + active_.unset(*i); + continue; + } + Rs.push_back(copy(r)); + } + + if (active_.empty()) { + delete this; + return NULL; + } + + Relation hull = SimpleHull(Rs, true, true); + + //hull.simplify(2,4); + + // check if actual loop is needed + std::pair result = find_simplest_assignment(hull, + hull.set_var(level_)); + if (result.second < INT_MAX) { + needLoop_ = false; + + bounds_ = Relation(hull.n_set()); + F_Exists *f_exists = bounds_.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map exists_mapping; + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(bounds_.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2 = replicate_floor_definition(hull, v, bounds_, + f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = bounds_.get_local(g); + else + v2 = bounds_.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const(result.first.get_const()); + bounds_.simplify(); + } + // loop iterates more than once, extract bounds now + else { + needLoop_ = true; + + bounds_ = Relation(hull.n_set()); + F_Exists *f_exists = bounds_.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map exists_mapping; + + Relation b = Gist(copy(hull), copy(known), 1); + bool has_unresolved_bound = false; + + std::set excluded_floor_vars; + excluded_floor_vars.insert(b.set_var(level_)); + for (GEQ_Iterator e(b.single_conjunct()->GEQs()); e; e++) + if ((*e).get_coef(b.set_var(level_)) != 0) { + bool is_bound = true; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) { + std::pair result = find_floor_definition( + b, cvi.curr_var(), excluded_floor_vars); + if (!result.first) { + is_bound = false; + has_unresolved_bound = true; + break; + } + } + + if (!is_bound) + continue; + + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(bounds_.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2 = replicate_floor_definition(b, v, + bounds_, f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = bounds_.get_local(g); + else + v2 = bounds_.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e).get_const()); + } + + if (has_unresolved_bound) { + b = Approximate(b); + b.simplify(2, 4); + //Simplification of Hull + hull = Approximate(hull); + hull.simplify(2, 4); + //end : Anand + for (GEQ_Iterator e(b.single_conjunct()->GEQs()); e; e++) + if ((*e).get_coef(b.set_var(level_)) != 0) + f_root->add_GEQ(*e); + } + bounds_.simplify(); + hull.simplify(2,4); + // Since current SimpleHull does not support max() upper bound or min() lower bound, + // we have to forcefully split the loop when hull approximation does not return any bound. + bool has_lb = false; + bool has_ub = false; + for (GEQ_Iterator e = bounds_.single_conjunct()->GEQs(); e; e++) { + if ((*e).get_coef(bounds_.set_var(level_)) > 0) + has_lb = true; + else if ((*e).get_coef(bounds_.set_var(level_)) < 0) + has_ub = true; + if (has_lb && has_ub) + break; + } + + if (!has_lb) { + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (GEQ_Iterator e = r.single_conjunct()->GEQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) > 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector restrictions(2); + restrictions[0] = Complement(copy(r2)); + restrictions[0].simplify(); + restrictions[1] = r2; + std::vector clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (EQ_Iterator e = r.single_conjunct()->EQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) != 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector restrictions(2); + if ((*e).get_coef(r.input_var(level_)) > 0) { + restrictions[0] = Complement(copy(r2)); + restrictions[0].simplify(); + restrictions[1] = r2; + } else { + restrictions[0] = r2; + restrictions[1] = Complement(copy(r2)); + restrictions[1].simplify(); + } + std::vector clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + } else if (!has_ub) { + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (GEQ_Iterator e = r.single_conjunct()->GEQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) < 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector restrictions(2); + restrictions[1] = Complement(copy(r2)); + restrictions[1].simplify(); + restrictions[0] = r2; + std::vector clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + for (int i = 0; i < Rs.size(); i++) { + Relation r = Approximate(copy(Rs[i])); + r.simplify(2, 4); + for (EQ_Iterator e = r.single_conjunct()->EQs(); e; e++) + if ((*e).get_coef(r.input_var(level_)) != 0) { + Relation r2 = Relation::True(num_level()); + r2.and_with_GEQ(*e); + r2.simplify(); + std::vector restrictions(2); + if ((*e).get_coef(r.input_var(level_)) > 0) { + restrictions[0] = Complement(copy(r2)); + restrictions[0].simplify(); + restrictions[1] = r2; + } else { + restrictions[0] = r2; + restrictions[1] = Complement(copy(r2)); + restrictions[1].simplify(); + } + std::vector clauses(2); + clauses[0] = this; + clauses[1] = this->clone(); + CG_result *cgr = new CG_split(codegen_, active_, + restrictions, clauses); + cgr = cgr->recompute(active_, copy(known), + copy(restriction)); + return cgr; + } + } + } + + if (!has_lb && !has_ub) + throw codegen_error( + "can't find any bound at loop level " + to_string(level_)); + else if (!has_lb) + throw codegen_error( + "can't find lower bound at loop level " + + to_string(level_)); + else if (!has_ub) + throw codegen_error( + "can't find upper bound at loop level " + + to_string(level_)); + } + bounds_.copy_names(hull); + bounds_.setup_names(); + + // additional guard/stride condition extraction + if (needLoop_) { + Relation cur_known = Intersection(copy(bounds_), copy(known_)); + cur_known.simplify(); + hull = Gist(hull, copy(cur_known), 1); + + std::pair result = find_simplest_stride(hull, + hull.set_var(level_)); + if (result.second != NULL) + if (abs(result.first.get_coef(hull.set_var(level_))) == 1) { + F_Exists *f_exists = bounds_.and_with_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map exists_mapping; + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(bounds_.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2; + if (v == result.second) + v2 = f_exists->declare(); + else + v2 = replicate_floor_definition(hull, v, bounds_, + f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = bounds_.get_local(g); + else + v2 = bounds_.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const(result.first.get_const()); + } else { + // since gist is not powerful enough on modular constraints for now, + // make an educated guess + coef_t stride = abs(result.first.get_coef(result.second)) + / gcd(abs(result.first.get_coef(result.second)), + abs( + result.first.get_coef( + hull.set_var(level_)))); + + Relation r1(hull.n_inp()); + F_Exists *f_exists = r1.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map exists_mapping; + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(r1.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2; + if (v == result.second) + v2 = f_exists->declare(); + else + v2 = replicate_floor_definition(hull, v, r1, + f_exists, f_root, exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r1.get_local(g); + else + v2 = r1.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const(result.first.get_const()); + r1.simplify(); + + bool guess_success = false; + for (GEQ_Iterator e(bounds_.single_conjunct()->GEQs()); e; e++) + if ((*e).get_coef(bounds_.set_var(level_)) == 1) { + Relation r2(hull.n_inp()); + F_Exists *f_exists = r2.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map exists_mapping; + EQ_Handle h = f_root->add_EQ(); + h.update_coef(f_exists->declare(), stride); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h.update_coef(r2.input_var(v->get_position()), + cvi.curr_coef()); + break; + case Wildcard_Var: { + Variable_ID v2 = replicate_floor_definition( + hull, v, r2, f_exists, f_root, + exists_mapping); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r2.get_local(g); + else + v2 = r2.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e).get_const()); + r2.simplify(); + + if (Gist(copy(r1), + Intersection(copy(cur_known), copy(r2)), 1).is_obvious_tautology() + && Gist(copy(r2), + Intersection(copy(cur_known), copy(r1)), + 1).is_obvious_tautology()) { + bounds_ = Intersection(bounds_, r2); + bounds_.simplify(); + guess_success = true; + break; + } + } + + // this is really a stride with non-unit coefficient for this loop variable + if (!guess_success) { + // TODO: for stride ax = b mod n it might be beneficial to + // generate modular linear equation solver code for + // runtime to get the starting position in printRepr, + // and stride would be n/gcd(|a|,n), thus this stride + // can be put into bounds_ too. + } + + } + + hull = Project(hull, hull.set_var(level_)); + hull.simplify(2, 4); + guard_ = Gist(hull, Intersection(copy(bounds_), copy(known_)), 1); + } + // don't generate guard for non-actual loop, postpone it. otherwise + // redundant if-conditions might be generated since for-loop semantics + // includes implicit comparison checking. -- by chun 09/14/10 + else + guard_ = Relation::True(num_level()); + guard_.copy_names(bounds_); + guard_.setup_names(); + + //guard_.simplify(); + // recursively down the AST + Relation new_known = Intersection(copy(known), + Intersection(copy(bounds_), copy(guard_))); + new_known.simplify(2, 4); + Relation new_restriction = Intersection(copy(restriction), + Intersection(copy(bounds_), copy(guard_))); + new_restriction.simplify(2, 4); + body_ = body_->recompute(active_, new_known, new_restriction); + if (body_ == NULL) { + delete this; + return NULL; + } else + return this; +} + +int CG_loop::populateDepth() { + int depth = body_->populateDepth(); + if (needLoop_) + depth_ = depth + 1; + else + depth_ = depth; + return depth_; +} + +std::pair CG_loop::liftOverhead(int depth, + bool propagate_up) { + if (depth_ > depth) { + assert(propagate_up == false); + std::pair result = body_->liftOverhead(depth, + false); + body_ = result.first; + return std::make_pair(this, Relation::True(num_level())); + } else { // (depth_ <= depth) + if (propagate_up) { + Relation r = pick_one_guard(guard_, level_); + if (!r.is_obvious_tautology()) + return std::make_pair(this, r); + } + + std::pair result; + if (propagate_up || needLoop_) + result = body_->liftOverhead(depth, true); + else + result = body_->liftOverhead(depth, false); + body_ = result.first; + if (result.second.is_obvious_tautology()) + return std::make_pair(this, result.second); + + // loop is an assignment, replace this loop variable in overhead condition + if (!needLoop_) { + result.second = Intersection(result.second, copy(bounds_)); + result.second = Project(result.second, + result.second.set_var(level_)); + result.second.simplify(2, 4); + } + + + int max_level = 0; + bool has_wildcard = false; + bool direction = true; + for (EQ_Iterator e(result.second.single_conjunct()->EQs()); e; e++) + if ((*e).has_wildcards()) { + if (has_wildcard) + assert(false); + else + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + } else + assert(false); + + if (!has_wildcard) { + int num_simple_geq = 0; + for (GEQ_Iterator e(result.second.single_conjunct()->GEQs()); e; + e++) + if (!(*e).has_wildcards()) { + num_simple_geq++; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) { + max_level = cvi.curr_var()->get_position(); + direction = (cvi.curr_coef() < 0) ? true : false; + } + } else { + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) { + max_level = cvi.curr_var()->get_position(); + } + } + assert( + (has_wildcard && num_simple_geq == 0) || (!has_wildcard && num_simple_geq == 1)); + } + + // check if this is the top loop level for splitting for this overhead + if (!propagate_up || (has_wildcard && max_level == level_ - 1) + || (!has_wildcard && max_level == level_)) { + std::vector restrictions(2); + std::vector clauses(2); + int saved_num_level = num_level(); + if (has_wildcard || direction) { + restrictions[1] = Complement(copy(result.second)); + restrictions[1].simplify(); + clauses[1] = this->clone(); + restrictions[0] = result.second; + clauses[0] = this; + } else { + restrictions[0] = Complement(copy(result.second)); + restrictions[0].simplify(); + clauses[0] = this->clone(); + restrictions[1] = result.second; + clauses[1] = this; + } + CG_result *cgr = new CG_split(codegen_, active_, restrictions, + clauses); + CG_result *new_cgr = cgr->recompute(active_, copy(known_), + copy(restriction_)); + new_cgr->populateDepth(); + assert(new_cgr==cgr); + if (static_cast(new_cgr)->clauses_.size() == 1) + // infinite recursion detected, bail out + return std::make_pair(new_cgr, Relation::True(saved_num_level)); + else + return cgr->liftOverhead(depth, propagate_up); + } else + return std::make_pair(this, result.second); + } +} + +Relation CG_loop::hoistGuard() { + + Relation r = body_->hoistGuard(); + + // TODO: should bookkeep catched contraints in loop output as enforced and check if anything missing + // if (!Gist(copy(b), copy(enforced)).is_obvious_tautology()) { + // fprintf(stderr, "need to generate extra guard inside the loop\n"); + // } + + if (!needLoop_) + r = Intersection(r, copy(bounds_)); + r = Project(r, r.set_var(level_)); + r = Gist(r, copy(known_), 1); + + Relation eliminate_existentials_r; + Relation eliminate_existentials_known; + + eliminate_existentials_r = copy(r); + if (!r.is_obvious_tautology()) { + eliminate_existentials_r = Approximate(copy(r)); + eliminate_existentials_r.simplify(2,4); + eliminate_existentials_known = Approximate(copy(known_)); + eliminate_existentials_known.simplify(2,4); + + eliminate_existentials_r = Gist( eliminate_existentials_r, eliminate_existentials_known, 1); + } + + + if (!eliminate_existentials_r.is_obvious_tautology()) { + // if (!r.is_obvious_tautology()) { + body_->removeGuard(r); + guard_ = Intersection(guard_, copy(r)); + guard_.simplify(); + } + + return guard_; + + // return ifList; + // } + + +} + +void CG_loop::removeGuard(const Relation &guard) { + known_ = Intersection(known_, copy(guard)); + known_.simplify(); + + guard_ = Gist(guard_, copy(known_), 1); + guard_.copy_names(known_); + guard_.setup_names(); +} + +CG_outputRepr *CG_loop::printRepr(int indent, CG_outputBuilder *ocg, + const std::vector &stmts, + const std::vector > &assigned_on_the_fly) const { + return printRepr(true, indent, ocg, stmts, assigned_on_the_fly); +} + +CG_outputRepr *CG_loop::printRepr(bool do_print_guard, int indent, + CG_outputBuilder *ocg, const std::vector &stmts, + const std::vector > &assigned_on_the_fly) const { + CG_outputRepr *guardRepr; + if (do_print_guard) + guardRepr = output_guard(ocg, guard_, assigned_on_the_fly); + else + guardRepr = NULL; + + Relation cur_known = Intersection(copy(known_), copy(guard_)); + cur_known.simplify(); + if (needLoop_) { + + if (checkLoopLevel) + if (level_ == checkLoopLevel) + if (active_.get(stmtForLoopCheck)) + fillInBounds = true; + + CG_outputRepr *ctrlRepr = output_loop(ocg, bounds_, level_, cur_known, + assigned_on_the_fly); + + fillInBounds = false; + + CG_outputRepr *bodyRepr = body_->printRepr( + (guardRepr == NULL) ? indent + 1 : indent + 2, ocg, stmts, + assigned_on_the_fly); + CG_outputRepr * loopRepr; + + if (guardRepr == NULL) + loopRepr = ocg->CreateLoop(indent, ctrlRepr, bodyRepr); + else + loopRepr = ocg->CreateLoop(indent + 1, ctrlRepr, bodyRepr); + + if (!smtNonSplitLevels.empty()) { + bool blockLoop = false; + bool threadLoop = false; + bool sync = false; + int firstActiveStmt = -1; + for (int s = 0; s < active_.size(); s++) { + if (active_.get(s)) { + if (firstActiveStmt < 0) + firstActiveStmt = s; + //We assume smtNonSplitLevels is only used to mark the first of + //the block or thread loops to be reduced in CUDA-CHiLL. Here we + //place some comments to help with final code generation. + //int idx = smtNonSplitLevels[s].index(level_); + + if (s < smtNonSplitLevels.size()) { + if (smtNonSplitLevels[s].size() > 0) + if (smtNonSplitLevels[s][0] == level_) { + blockLoop = true; + } + //Assume every stmt marked with a thread loop index also has a block loop idx + if (smtNonSplitLevels[s].size() > 1) + if (smtNonSplitLevels[s][1] == level_) { + threadLoop = true; + } + } + } + } + if (blockLoop && threadLoop) { + fprintf(stderr, + "Warning, have %d level more than once in smtNonSplitLevels\n", + level_); + threadLoop = false; + } + std::string preferredIdx; + if (loopIdxNames.size() + && (level_ / 2) - 1 < loopIdxNames[firstActiveStmt].size()) + preferredIdx = loopIdxNames[firstActiveStmt][(level_ / 2) - 1]; + for (int s = 0; s < active_.size(); s++) { + if (active_.get(s)) { + for (int i = 0; i < syncs.size(); i++) { + if (syncs[i].first == s + && strcmp(syncs[i].second.c_str(), + preferredIdx.c_str()) == 0) { + sync = true; + //printf("FOUND SYNC\n"); + } + + } + } + + } + if (threadLoop || blockLoop || preferredIdx.length() != 0) { + char buf[1024]; + std::string loop; + if (blockLoop) + loop = "blockLoop "; + if (threadLoop) + loop = "threadLoop "; + if (preferredIdx.length() != 0 && sync) { + sprintf(buf, "~cuda~ %spreferredIdx: %s sync", loop.c_str(), + preferredIdx.c_str()); + } else if (preferredIdx.length() != 0) { + sprintf(buf, "~cuda~ %spreferredIdx: %s", loop.c_str(), + preferredIdx.c_str()); + } else { + sprintf(buf, "~cuda~ %s", loop.c_str()); + } + + + loopRepr = ocg->CreateAttribute(loopRepr, buf); + } + + } + if (guardRepr == NULL) + return loopRepr; + else + return ocg->CreateIf(indent, guardRepr, loopRepr, NULL); + } else { + std::pair > result = + output_assignment(ocg, bounds_, level_, cur_known, + assigned_on_the_fly); + guardRepr = ocg->CreateAnd(guardRepr, result.first); + + if (result.second.second < CodeGen::var_substitution_threshold) { + std::vector > atof = + assigned_on_the_fly; + atof[level_ - 1] = result.second; + CG_outputRepr *bodyRepr = body_->printRepr( + (guardRepr == NULL) ? indent : indent + 1, ocg, stmts, + atof); + delete atof[level_ - 1].first; + if (guardRepr == NULL) + return bodyRepr; + else + return ocg->CreateIf(indent, guardRepr, bodyRepr, NULL); + } else { + CG_outputRepr *assignRepr = ocg->CreateAssignment( + (guardRepr == NULL) ? indent : indent + 1, + output_ident(ocg, bounds_, + const_cast(this)->bounds_.set_var( + level_), assigned_on_the_fly), + result.second.first); + CG_outputRepr *bodyRepr = body_->printRepr( + (guardRepr == NULL) ? indent : indent + 1, ocg, stmts, + assigned_on_the_fly); + if (guardRepr == NULL) + return ocg->StmtListAppend(assignRepr, bodyRepr); + else + return ocg->CreateIf(indent, guardRepr, + ocg->StmtListAppend(assignRepr, bodyRepr), NULL); + } + + } +} + +CG_result *CG_loop::clone() const { + return new CG_loop(codegen_, active_, level_, body_->clone()); +} + +void CG_loop::dump(int indent) const { + std::string prefix; + for (int i = 0; i < indent; i++) + prefix += " "; + std::cout << prefix << "LOOP (level " << level_ << "): " << active_ + << std::endl; + std::cout << prefix << "known: "; + const_cast(this)->known_.print(); + std::cout << prefix << "restriction: "; + const_cast(this)->restriction_.print(); + std::cout << prefix << "bounds: "; + const_cast(this)->bounds_.print(); + std::cout << prefix << "guard: "; + const_cast(this)->guard_.print(); + body_->dump(indent + 1); +} + +//----------------------------------------------------------------------------- +// Class: CG_leaf +//----------------------------------------------------------------------------- + +CG_result* CG_leaf::recompute(const BoolSet<> &parent_active, + const Relation &known, const Relation &restriction) { + active_ &= parent_active; + known_ = copy(known); + + guards_.clear(); + for (BoolSet<>::iterator i = active_.begin(); i != active_.end(); i++) { + Relation r = Intersection( + copy(codegen_->projected_IS_[num_level() - 1][*i]), + copy(restriction)); + r.simplify(2, 4); + if (!r.is_upper_bound_satisfiable()) + active_.unset(*i); + else { + r = Gist(r, copy(known), 1); + if (!r.is_obvious_tautology()) { + guards_[*i] = r; + guards_[*i].copy_names(known); + guards_[*i].setup_names(); + } + } + } + + + if (active_.empty()) { + delete this; + return NULL; + } else + return this; +} + +std::pair CG_leaf::liftOverhead(int depth, bool) { + if (depth == 0) + return std::make_pair(this, Relation::True(num_level())); + + for (std::map::iterator i = guards_.begin(); + i != guards_.end(); i++) { + Relation r = pick_one_guard(i->second); + if (!r.is_obvious_tautology()) { + bool has_wildcard = false; + int max_level = 0; + for (EQ_Iterator e(r.single_conjunct()->EQs()); e; e++) { + if ((*e).has_wildcards()) + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + } + for (GEQ_Iterator e(r.single_conjunct()->GEQs()); e; e++) { + if ((*e).has_wildcards()) + has_wildcard = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var()->kind() == Input_Var + && cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + } + + if (!(has_wildcard && max_level == codegen_->num_level())) + return std::make_pair(this, r); + } + } + + return std::make_pair(this, Relation::True(num_level())); +} + +Relation CG_leaf::hoistGuard() { + std::vector guards; + for (BoolSet<>::iterator i = active_.begin(); i != active_.end(); i++) { + std::map::iterator j = guards_.find(*i); + if (j == guards_.end()) { + Relation r = Relation::True(num_level()); + r.copy_names(known_); + r.setup_names(); + return r; + } else { + guards.push_back(j->second); + } + } + + return SimpleHull(guards, true, true); +} + +void CG_leaf::removeGuard(const Relation &guard) { + known_ = Intersection(known_, copy(guard)); + known_.simplify(); + + std::map::iterator i = guards_.begin(); + while (i != guards_.end()) { + i->second = Gist(i->second, copy(known_), 1); + if (i->second.is_obvious_tautology()) + guards_.erase(i++); + else + ++i; + } +} + +CG_outputRepr *CG_leaf::printRepr(int indent, CG_outputBuilder *ocg, + const std::vector &stmts, + const std::vector > &assigned_on_the_fly) const { + return leaf_print_repr(active_, guards_, NULL, known_, indent, ocg, + codegen_->remap_, codegen_->xforms_, stmts, assigned_on_the_fly); +} + +CG_result *CG_leaf::clone() const { + return new CG_leaf(codegen_, active_); +} + +void CG_leaf::dump(int indent) const { + std::string prefix; + for (int i = 0; i < indent; i++) + prefix += " "; + std::cout << prefix << "LEAF: " << active_ << std::endl; + std::cout << prefix << "known: "; + const_cast(this)->known_.print(); + for (std::map::const_iterator i = guards_.begin(); + i != guards_.end(); i++) { + std::cout << prefix << "guard #" << i->first << ":"; + const_cast(i->second).print(); + } +} + +} diff --git a/omega/code_gen/src/CG_roseBuilder.cc b/omega/code_gen/src/CG_roseBuilder.cc new file mode 100644 index 0000000..eb16830 --- /dev/null +++ b/omega/code_gen/src/CG_roseBuilder.cc @@ -0,0 +1,1533 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + generate suif code for omega + + Notes: + + History: + 02/01/06 created by Chun Chen + *****************************************************************************/ + +#include +#include +#include + +struct ir_error: public std::runtime_error { + ir_error(const std::string &msg) : + std::runtime_error(msg) { + } +}; + +using namespace SageBuilder; +using namespace SageInterface; +using namespace OmpSupport; + +namespace omega { + +//----------------------------------------------------------------------------- +// make suif initilization happy +//----------------------------------------------------------------------------- +char *k_ocg_comment; + +// void __attribute__ ((constructor)) my_init(void) { +// ANNOTE(k_ocg_comment, "omega_comment", TRUE); +// } + +/* + const char *libcode_gen_ver_string = ""; + const char *libcode_gen_who_string = ""; + const char *libcode_gen_suif_string = ""; + + void init_code_gen(int&, char* []) { + ANNOTE(k_ocg_comment, "omega_comment", TRUE); + } + + void exit_code_gen(void) { + } + */ +CG_roseBuilder::CG_roseBuilder(int is_fortran, SgGlobal* global, SgGlobal* firstScope, + SgSymbolTable* symtab, SgSymbolTable* symtab2, SgNode* root) : + isFortran(is_fortran), global_(global), global_scope(firstScope), symtab_(symtab), symtab2_( + symtab2), root_(root) { +} + + +CG_roseBuilder::~CG_roseBuilder() { +} + +// Manu:: returns true if input is in fortran, else returns false +bool CG_roseBuilder::isInputFortran() const{ + if (isFortran) + return true; + else + return false; +} + +//----------------------------------------------------------------------------- +// place holder generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateSubstitutedStmt(int, CG_outputRepr *stmt, + const std::vector &vars, std::vector &subs) const { + + SgStatementPtrList* list = static_cast(stmt)->list_; + SgNode *tnl; + SgStatement* statement; + if (list != NULL) { + //statement = *((*list).begin()); + //tnl = isSgNode(statement); + delete stmt; + for (int i = 0; i < subs.size(); i++) { + if (subs[i] == NULL) + continue; + + CG_roseRepr *repr = static_cast(subs[i]); + SgExpression* op = repr->op_; + + for (SgStatementPtrList::iterator it = (*list).begin(); + it != (*list).end(); it++) { + statement = (*it); + tnl = isSgNode(statement); + + // std::string master = tnl->unparseToString(); + + int j; + int not_in_symtab_; + + not_in_symtab_ = 0; + + SgVariableSymbol *vs = symtab_->find_variable( + SgName(vars[i].c_str())); + + if (vs == NULL) { + + not_in_symtab_ = 1; + + vs = symtab2_->find_variable(SgName(vars[i].c_str())); + } + if (vs != NULL) { + //std::string x = vars[i].c_str() ; + //std::string y = isSgNode(op)->unparseToString(); + + std::vector array = substitute(tnl, + (const SgVariableSymbol*) vs, op, root_); + for (std::vector::iterator it = + array.begin(); it != array.end(); it++) { + + // std::string z = isSgNode(array[j])->unparseToString(); + if (isSgVarRefExp(op)) { + if (strcmp( + isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), + vs->get_name().getString().c_str())) { + + (*it)->set_symbol( + isSgVarRefExp(op)->get_symbol()); + // std::string z = isSgNode(array[j])->unparseToString(); + + // isSgBinaryOp(array[j]->get_parent())->replace_expression(array[j], op); + + } + } else if (isSgExpression(op)) { + + if (isSgBinaryOp((*it)->get_parent())) + isSgBinaryOp((*it)->get_parent())->replace_expression( + *it, op); + else if (isSgUnaryOp((*it)->get_parent())) + isSgUnaryOp((*it)->get_parent())->replace_expression( + *it, op); + else if (isSgExprListExp((*it)->get_parent())) + isSgExprListExp((*it)->get_parent())->replace_expression( + *it, op); + else + throw ir_error("unrecognized expression type"); + } + + } + /* std::vector array2 = substitute (tnl,(const SgVariableSymbol*) vs, op, root_); + if(array2.size() != 0) + throw ir_error("variable replacement unsuccessful"); + */ + } + + } + + delete repr; + subs[i] = NULL; + + if (subs[i] != NULL) + throw ir_error("not freed properly"); + + } + + return new CG_roseRepr(list); + + } else { + tnl = static_cast(stmt)->tnl_; + //std::string master = tnl->unparseToString(); + + if (tnl == NULL) + throw ir_error("both list and tnl are null!!"); + + delete stmt; + int j; + int not_in_symtab_; + for (int i = 0; i < subs.size(); i++) { + if (subs[i] == NULL) + continue; + not_in_symtab_ = 0; + + + CG_roseRepr *repr = static_cast(subs[i]); + SgExpression* op = repr->op_; + delete repr; + subs[i] = NULL; + + SgVariableSymbol *vs = symtab_->find_variable( + SgName(vars[i].c_str())); + + if (vs == NULL) { + + not_in_symtab_ = 1; + + vs = symtab2_->find_variable(SgName(vars[i].c_str())); + } + if (vs != NULL) { + //std::string x = vars[i].c_str() ; + //std::string y = isSgNode(op)->unparseToString(); + std::vector array = substitute(tnl, vs, op, + root_); + + if (not_in_symtab_ && isSgVarRefExp(op)) { + if (strcmp( + isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), + vs->get_name().getString().c_str())) { + // symtab2_->remove(vs); + } + } + /* else if(not_in_symtab_ && isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())){ + if(strcmp(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()->get_name().getString().c_str(),\ + vs->get_name().getString().c_str())){ + symtab2_->remove(vs); + } + }*/ + //symtab2_->remove(vs); + for (std::vector::iterator j = array.begin(); + j != array.end(); j++) { + // std::string z = isSgNode(array[j])->unparseToString(); + + if (isSgVarRefExp(op)) { + if (strcmp( + isSgVarRefExp(op)->get_symbol()->get_name().getString().c_str(), + vs->get_name().getString().c_str())) { + (*j)->set_symbol(isSgVarRefExp(op)->get_symbol()); + //isSgBinaryOp(array[j]->get_parent())->replace_expression(array[j], op); + // std::string z = isSgNode(array[j])->unparseToString(); + + } + } else if (isSgExpression(op)) { + + if (isSgBinaryOp((*j)->get_parent())) + isSgBinaryOp((*j)->get_parent())->replace_expression( + *j, op); + else if (isSgUnaryOp((*j)->get_parent())) + isSgUnaryOp((*j)->get_parent())->replace_expression( + *j, op); + else if (isSgExprListExp((*j)->get_parent())) { // Manu:: fortran indices are stored this way + isSgExprListExp((*j)->get_parent())->replace_expression(*j, op); + } + else + throw ir_error("unrecognized expression type"); + /* if(strcmp(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()->get_name().getString().c_str(),\ + vs->get_name().getString().c_str() )){ + array[j]->set_symbol(isSgVarRefExp(isSgAddOp(op)->get_lhs_operand())->get_symbol()); + + */ + + } + + } + /* std::vector array2 = substitute (tnl,(const SgVariableSymbol*) vs, op, root_); + if(array2.size() != 0) + throw ir_error("variable replacement unsuccessful"); + */ + } + /* SgExpression* exp = NULL; + + if(stmt1 = isSgStatement(tnl)){ + if (SgExprStatement* expr_stmt = isSgExprStatement(stmt1)) + exp = expr_stmt->get_expression(); + else if( block = isSgBasicBlock(tnl)){ + SgStatementPtrList& stmts = block->get_statements(); + SgExpression* exp2; + for(int i =0; i < stmts.size(); i++){ + if(isSgExprStatement(stmts[i])){ + exp2 = isSgExprStatement(stmts[i])->get_expression(); + if(exp2 != NULL){ + + if(isSgBinaryOp(exp2)) { + substitute(isSgBinaryOp(exp2)->get_lhs_operand(), vs, op, root_, exp2); + substitute(isSgBinaryOp(exp2)->get_rhs_operand(), vs, op, root_, exp2); + } + else if (isSgUnaryOp(exp2)) + substitute(isSgUnaryOp(exp2)->get_operand(), vs, op, root_, exp2); + + + }//end if + + }//end if + }//end for + + }//end else + else if(SgForStatement* for_stmt = isSgForStatement(tnl)){ + SgForStatement* temp = for_stmt; + while(isSgForStatement(temp)){ + + + + } + + + + + } + + + }//end if + else + exp = isSgExpression(tnl); + + if(exp != NULL){ + if(isSgBinaryOp(exp)) { + substitute(isSgBinaryOp(exp)->get_lhs_operand(), vs, op, root_, exp); + substitute(isSgBinaryOp(exp)->get_rhs_operand(), vs, op, root_, exp); + } + else if (isSgUnaryOp(exp)) + substitute(isSgUnaryOp(exp)->get_operand(), vs, op, root_, exp); + + } + // if (op.is_instr()) + // delete op.instr(); + } + */ + } + return new CG_roseRepr(tnl); + } + +} + +//----------------------------------------------------------------------------- +// assignment generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateAssignment(int, CG_outputRepr *lhs, + CG_outputRepr *rhs) const { + if (lhs == NULL || rhs == NULL) { + fprintf(stderr, "Code generation: Missing lhs or rhs\n"); + return NULL; + } + + SgExpression* src = static_cast(rhs)->op_; + SgExpression* dst = static_cast(lhs)->op_; + + SgExprStatement* ins = buildAssignStatement(dst, src); + src->set_parent(ins); + dst->set_parent(ins); + + SgStatementPtrList* new_list = new SgStatementPtrList; + + (*new_list).push_back(isSgStatement(ins)); + + delete lhs; + delete rhs; + + return new CG_roseRepr(new_list); + +} + +//----------------------------------------------------------------------------- +// function invocation generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateInvoke(const std::string &fname, + std::vector &list) const { + + // Manu:: debug +// std::cout << "--------- CreateInvoke --------- \n"; + + if (fname == std::string("max") || fname == std::string("min")) { + if (list.size() == 0) { + return NULL; + } else if (list.size() == 1) { + return list[0]; + } else { + int last = list.size() - 1; + SgExpression* op2 = static_cast(list[last])->op_; + delete list[last]; + list.erase(list.end()-1); + CG_roseRepr *repr = static_cast(CreateInvoke(fname, + list)); + SgExpression* op1 = repr->op_; + + + SgExpression *ins; + SgExprListExp* arg_list = buildExprListExp(); + appendExpression(arg_list, op1); + appendExpression(arg_list, op2); + SgVarRefExp* opaque_var; + + + if (fname == std::string("max")) { + opaque_var = buildOpaqueVarRefExp("__rose_gt", global_); + ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list)); + + // Manu:: fortran support + if (isInputFortran()) { + SgName fName("merge"); + SgTypeInt *retType = buildIntType(); + + SgExpression *cond = static_cast(CreateLE(new CG_roseRepr(op2), new CG_roseRepr(op1)))->op_; + appendExpression(arg_list, cond); + ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); +// std::cout << "--------- CreateInvoke:: " << isSgNode(ins)->unparseToString().c_str() << "\n"; + } + + } else { + opaque_var = buildOpaqueVarRefExp("__rose_lt", global_); + ins = isSgExpression(buildFunctionCallExp(opaque_var, arg_list)); + + // Manu:: fortran support + if (isInputFortran()) { + SgName fName("merge"); + SgTypeInt *retType = buildIntType(); + + SgExpression *cond = static_cast(CreateLE(new CG_roseRepr(op1), new CG_roseRepr(op2)))->op_; + appendExpression(arg_list, cond); + ins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); +// std::cout << "--------- CreateInvoke:: " << isSgNode(ins)->unparseToString().c_str() << "\n"; + } + + } + + repr->op_ = ins; + return repr; + } + } else { + fprintf(stderr, + "Code generation: invoke function io_call not implemented\n"); + return NULL; + } + +} + +//----------------------------------------------------------------------------- +// comment generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateComment(int, + const std::string &commentText) const { + if (commentText == std::string("")) { + return NULL; + } + + SgLocatedNode *tnl = new SgLocatedNode(); + buildComment(tnl, "//omega_comment: " + commentText); + + return new CG_roseRepr(isSgNode(tnl)); + +} + +//----------------------------------------------------------------------------- +// if stmt gen operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateIf(int, CG_outputRepr *guardList, + CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { + + // static int if_counter = 1; + // std::string s = std::string("omegaif_")+to_string(if_counter++); + // SgLabelStatement* label =buildLabelStatement(SgName(const_cast(s.c_str()))); + + if (true_stmtList == NULL && false_stmtList == NULL) { + delete guardList; + return NULL; + } else if (guardList == NULL) { + return StmtListAppend(true_stmtList, false_stmtList); + } + + SgExpression* header = static_cast(guardList)->op_; + + SgStatementPtrList *then_part1, *else_part1; + SgStatement* then_part; + SgStatement* else_part; + SgBasicBlock* then_part2; + SgBasicBlock* else_part2; + if (true_stmtList != NULL) { + then_part1 = static_cast(true_stmtList)->list_; + if (then_part1 != NULL) { + then_part = *((*then_part1).begin()); + + if ((*then_part1).size() > 1) { + then_part2 = buildBasicBlock(); + for (SgStatementPtrList::iterator it = (*then_part1).begin(); + it != (*then_part1).end(); it++) { + then_part2->append_statement(*it); + + } + then_part = isSgStatement(then_part2); + + } + } else { + // Manu:: fortran support (if part) + if (isInputFortran()) { + then_part2 = buildBasicBlock(); + then_part2->append_statement(isSgStatement(static_cast(true_stmtList)->tnl_)); + then_part = isSgStatement(then_part2); + } else + then_part = isSgStatement(static_cast(true_stmtList)->tnl_); + } + } else { + then_part = NULL; + } + if (false_stmtList != NULL) { + else_part1 = static_cast(false_stmtList)->list_; + if (else_part1 != NULL) { + else_part = *((*else_part1).begin()); + if ((*else_part1).size() > 1) { + else_part2 = buildBasicBlock(); + for (SgStatementPtrList::iterator it2 = (*else_part1).begin(); + it2 != (*else_part1).end(); it2++) { + else_part2->append_statement(*it2); + + } + else_part = isSgStatement(else_part2); + + } + } else { + // Manu:: fortran support (if part) + if (isInputFortran()) { + else_part2 = buildBasicBlock(); + else_part2->append_statement(isSgStatement(static_cast(false_stmtList)->tnl_)); + else_part = isSgStatement(else_part2); + } else + else_part = isSgStatement(static_cast(false_stmtList)->tnl_); + } + } else { + else_part = NULL; + } + + SgIfStmt* ti = buildIfStmt(header, isSgStatement(then_part), + isSgStatement(else_part)); + +// label->set_scope(ti);//may have to be shifted to after symbol table insertion +// SgLabelSymbol* if_label = isSgLabelSymbol(label->get_symbol_from_symbol_table()); + +// symtab_->insert( SgName(const_cast(s.c_str())) , isSgSymbol(if_label)); + + delete guardList; + delete true_stmtList; + delete false_stmtList; + + return new CG_roseRepr(isSgNode(ti)); + +} + +//----------------------------------------------------------------------------- +// inductive variable generation, to be used in CreateLoop as control +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, CG_outputRepr *upper, CG_outputRepr *step) const { + + if (index == NULL || lower == NULL || upper == NULL) { + fprintf(stderr, + "Code generation: something wrong in CreateInductive\n"); + return NULL; + } + + if (step == NULL) + step = new CG_roseRepr(isSgExpression(buildIntVal(1))); + + SgVarRefExp *index_sym = isSgVarRefExp( + static_cast(index)->op_); + SgExpression* lower_bound = static_cast(lower)->op_; + SgExpression* upper_bound = static_cast(upper)->op_; + SgExpression* step_size = static_cast(step)->op_; + + /* label_sym *contLabel = new label_sym(""); + label_sym *brkLabel = new label_sym(""); may not be required on rose?! + */ + + SgStatement* for_init_stmt = buildAssignStatement(index_sym, lower_bound); + SgLessOrEqualOp* cond = buildLessOrEqualOp(index_sym, upper_bound); + SgExprStatement* test = buildExprStatement(cond); + SgPlusAssignOp* increment = buildPlusAssignOp(index_sym, step_size); + SgForStatement *for_stmt = buildForStatement(for_init_stmt, + isSgStatement(test), increment, NULL); + + delete index; + delete lower; + delete upper; + delete step; + + + // Manu + if (isInputFortran()) { + // std::cout << "CG_roseBuilder:: need to construct a fortran do statement\n"; + SgFortranDo * forStmt=new SgFortranDo(Sg_File_Info::generateDefaultFileInfoForTransformationNode()); + forStmt->set_has_end_statement(true); + forStmt->set_bound(upper_bound); + forStmt->set_increment(step_size); + forStmt->set_initialization(isSgExprStatement(for_init_stmt)->get_expression()); + return new CG_roseRepr(isSgNode(forStmt)); + } else { +// std::cout << "CG_roseBuilder:: for statement is fine\n"; + + return new CG_roseRepr(isSgNode(for_stmt)); + + } + +} + +//----------------------------------------------------------------------------- +// Attribute Creation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const { + + SgNode *tnl = static_cast(control)->tnl_; + + tnl->setAttribute("omega_comment", new AstTextAttribute(commentText)); + + return static_cast(control); + +} + +//----------------------------------------------------------------------------- +// Pragma Attribute +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreatePragmaAttribute(CG_outputRepr *stmt, int looplevel, const std::string &pragmaText) const { + SgNode *tnl = static_cast(stmt)->tnl_; + CodeInsertionAttribute* attr = NULL; + if (!tnl->attributeExists("code_insertion")) { + attr = new CodeInsertionAttribute(); + tnl->setAttribute("code_insertion", attr); + } + else { + attr = static_cast(tnl->getAttribute("code_insertion")); + } + attr->add(new PragmaInsertion(looplevel, pragmaText)); + return stmt; +} + +//----------------------------------------------------------------------------- +// Prefetch Attribute +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreatePrefetchAttribute(CG_outputRepr* stmt, int looplevel, const std::string &arrName, int hint) const { + SgNode *tnl = static_cast(stmt)->tnl_; + CodeInsertionAttribute *attr = getOrCreateCodeInsertionAttribute(tnl); + attr->add(new MMPrefetchInsertion(looplevel, arrName, hint)); +} + +//----------------------------------------------------------------------------- +// loop stmt generation +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateLoop(int, CG_outputRepr *control, + CG_outputRepr *stmtList) const { + if (stmtList == NULL) { + delete control; + return NULL; + } else if (control == NULL) { + fprintf(stderr, "Code generation: no inductive for this loop\n"); + return stmtList; + } + + SgNode *tnl = static_cast(control)->tnl_; + SgForStatement *tf = isSgForStatement(tnl); + + // Manu :: fortran support + SgFortranDo *tfd = NULL; + if (isInputFortran()) { + tfd = isSgFortranDo(tnl); + } + // Manu:: debug +/* if (!tf) { + std::cout << "CreateLoop:: Not a for loop\n"; + if (isSgFortranDo(tnl)) + std::cout << "CreateLoop:: It is a fortran do loop\n"; + } +*/ + + SgStatementPtrList * body = static_cast(stmtList)->list_; + + if (body != NULL) { + if (!((*body).empty())) { + if ((*body).size() == 1) { + // if(isSgBasicBlock(*((*body).begin()))){ + if (!isInputFortran()) { // Manu:: added if-else for fortran support + tf->set_loop_body(*((*body).begin())); + (*((*body).begin()))->set_parent(tf); + } else { + SgBasicBlock* bb1 = buildBasicBlock(); + bb1->set_parent(tfd); + bb1->append_statement(*((*body).begin())); + tfd->set_body(bb1); + } + // } + /* else{ + SgBasicBlock* bb1 = buildBasicBlock(); + bb1->set_parent(tf); + bb1->append_statement(*((*body).begin())); + tf->set_loop_body(bb1); + + }*/ + } else { + // Manu:: support for fortran label (do - continue) + SgName *sname = NULL; + + SgBasicBlock* bb = buildBasicBlock(); + if (!isInputFortran()) + bb->set_parent(tf); + else + bb->set_parent(tfd); + for (SgStatementPtrList::iterator it = (*body).begin(); + it != (*body).end(); it++) { + bb->append_statement(*it); + (*it)->set_parent(bb); + } + if (!isInputFortran()) + tf->set_loop_body(bb); + else { + tfd->set_body(bb); + } + } + } + } else { + SgNode* tnl2 = static_cast(stmtList)->tnl_; + + if (tnl2 != NULL) { + if (!isInputFortran()) { + tf->set_loop_body(isSgStatement(tnl2)); + tnl2->set_parent(tf); + } else { + SgBasicBlock* bb1 = buildBasicBlock(); + bb1->set_parent(tfd); + bb1->append_statement(isSgStatement(tnl2)); + tfd->set_body(bb1); + tnl2->set_parent(bb1); + } + } + } + + delete stmtList; + + return control; +} + +//----------------------------------------------------------------------------- +// basic int, identifier gen operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateInt(int _i) const { + return new CG_roseRepr(isSgExpression(buildIntVal(_i))); +} +bool CG_roseBuilder::isInteger(CG_outputRepr *op) const{ + + SgExpression *op1 = static_cast(op)->op_; + + if(op1) + if(isSgIntVal(op1)) + return true; + + return false; +} +CG_outputRepr* CG_roseBuilder::CreateIdent(const std::string &_s) const { + + SgVariableSymbol *vs = symtab_->find_variable(SgName(_s.c_str())); + SgVariableSymbol *vs2 = symtab2_->find_variable(SgName(_s.c_str())); + + if (vs == NULL && vs2 == NULL) { + + SgVariableDeclaration* defn = buildVariableDeclaration( + SgName(_s.c_str()), buildIntType()); + SgInitializedNamePtrList& variables = defn->get_variables(); + SgInitializedNamePtrList::const_iterator i = variables.begin(); + SgInitializedName* initializedName = *i; + vs = new SgVariableSymbol(initializedName); + prependStatement(defn, isSgScopeStatement(root_)); + + vs->set_parent(symtab2_); + symtab2_->insert(SgName(_s.c_str()), vs); + return new CG_roseRepr(isSgExpression(buildVarRefExp(vs))); + + } + + /* May have problem */ + + if (!isSgExpression(buildVarRefExp(SgName(_s.c_str())))) + throw ir_error("error in Create ident!!"); + if (vs2 != NULL) + return new CG_roseRepr(isSgExpression(buildVarRefExp(vs2))); + + return new CG_roseRepr(isSgExpression(buildVarRefExp(vs))); + +} + +//----------------------------------------------------------------------------- +// binary arithmetic operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreatePlus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) { + return lop; + } else if (lop == NULL) { + return rop; + } + + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + SgAddOp *ins = buildAddOp(op1, op2); + op1->set_parent(ins); + op2->set_parent(ins); + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateMinus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) { + return lop; /* May Cause Problem */ + } else if (lop == NULL) { + SgExpression *op = static_cast(rop)->op_; + SgMinusOp *ins = buildMinusOp(op); + + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + } else { + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + SgSubtractOp *ins = buildSubtractOp(op1, op2); + op1->set_parent(ins); + op2->set_parent(ins); + delete lop; + delete rop; + return new CG_roseRepr(isSgExpression(ins)); + } + +} + +CG_outputRepr* CG_roseBuilder::CreateTimes(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + if (rop != NULL) { + rop->clear(); + delete rop; + } + if (lop != NULL) { + lop->clear(); + delete lop; + } + return NULL; + } + + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + SgMultiplyOp *ins = buildMultiplyOp(op1, op2); + op1->set_parent(ins); + op2->set_parent(ins); + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateIntegerFloor(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) { + fprintf(stderr, "Code generation: divide by NULL\n"); + return NULL; + } else if (lop == NULL) { + delete rop; + return NULL; + } + + // (6+5)*10 / 4 + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + // bugs in SUIF prevent use of correct io_divfloor + SgDivideOp *ins = buildDivideOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateIntegerMod(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + return NULL; + } + + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + // bugs in SUIF prevent use of correct io_mod + SgModOp *ins; + if (!isInputFortran()) { + ins = buildModOp(op1, op2); + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + } else { // Manu:: fortran mod is a function call and not an operator (f77 and f90) + SgExpression *fins; + SgName fName("MOD"); + SgExprListExp* arg_list = buildExprListExp(); + appendExpression(arg_list, op1); + appendExpression(arg_list, op2); + SgTypeInt *retType = buildIntType(); + fins = isSgExpression(buildFunctionCallExp(fName, retType, arg_list, global_)); + return new CG_roseRepr(isSgExpression(fins)); + } + +} + +//----------------------------------------------------------------------------- +// binary logical operations +//----------------------------------------------------------------------------- +CG_outputRepr* CG_roseBuilder::CreateAnd(CG_outputRepr *lop, + CG_outputRepr *rop) const { + /*if (rop == NULL || lop == NULL) { + return NULL; + }*/ + + if (rop == NULL) + return lop; + else if (lop == NULL) + return rop; + + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + SgAndOp *ins = buildAndOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +//----------------------------------------------------------------------------- +// binary relational operations +//----------------------------------------------------------------------------- +/*CG_outputRepr* CG_roseBuilder::CreateGE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + return CreateLE(rop, lop); +}*/ + +CG_outputRepr* CG_roseBuilder::CreateLE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + return NULL; + } + + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + SgLessOrEqualOp *ins = buildLessOrEqualOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +CG_outputRepr* CG_roseBuilder::CreateEQ(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + return NULL; + } + + SgExpression* op1 = static_cast(lop)->op_; + SgExpression* op2 = static_cast(rop)->op_; + + SgEqualityOp *ins = buildEqualityOp(op1, op2); + + delete lop; + delete rop; + + return new CG_roseRepr(isSgExpression(ins)); + +} + +//----------------------------------------------------------------------------- +// stmt list gen operations +//----------------------------------------------------------------------------- +/*CG_outputRepr* CG_roseBuilder::CreateStmtList(CG_outputRepr *singleton) const { + + if (singleton == NULL) { + return new CG_roseRepr(new SgStatementPtrList); + } + + SgStatementPtrList *tnl = static_cast(singleton)->list_; + SgNode* sgn = static_cast(singleton)->tnl_; + + if (tnl == NULL) + tnl = new SgStatementPtrList; + + if (sgn == NULL) { + SgExpression* op = static_cast(singleton)->op_; + + if (op != NULL) + (*tnl).push_back( + buildExprStatement( + static_cast(singleton)->op_)); + + } else + (*tnl).push_back(isSgStatement(sgn)); + + delete singleton; + return new CG_roseRepr(tnl); + +// tnl = isSgNode(buildBasicBlock(buildExprStatement(static_cast(singleton)->op_))); + +// delete singleton; +// return new CG_roseRepr(tnl); + +} + +CG_outputRepr* CG_roseBuilder::StmtListInsertLast(CG_outputRepr *list, + CG_outputRepr *node) const { + return StmtListAppend(list, node); +} +*/ +CG_outputRepr* CG_roseBuilder::StmtListAppend(CG_outputRepr *list1, + CG_outputRepr *list2) const { + + if (list2 == NULL) { + return list1; + } else if (list1 == NULL) { + return list2; + } + + // SgStatement* parent; + // SgStatement* stmt1; + // SgStatement* stmt2; + + SgStatementPtrList* new_list; + + SgStatementPtrList* tnl1 = static_cast(list1)->list_; + SgStatementPtrList* tnl2 = static_cast(list2)->list_; + SgNode* one = static_cast(list1)->tnl_; + SgNode* two = static_cast(list2)->tnl_; + + SgExpression* exp1 = static_cast(list1)->op_; + SgExpression* exp2 = static_cast(list2)->op_; + + if (exp1 || exp2) + throw ir_error("error in stmtlistappend!!"); + + if (tnl1 && one) + throw ir_error("error in stmtlistappend!!"); + + if (tnl2 && two) + throw ir_error("error in stmtlistappend!!"); +// SgNode* sg1 = static_cast(list1)->tnl_; + +//if((*tnl1).empty()){ + +// if(SgStatement* stmt = isSgStatement(sg1)) +// (*tnl1).push_back(stmt); +//else if(isSgScopeStatement(sg1)){ +// SgStatementPtrList scopeStmtPtrLst = isSgScopeStatement(sg1)->generateStatementList(); + +// for(SgStatementPtrList::iterator it1 = scopeStmtPtrLst.begin();it1 != scopeStmtPtrLst.end(); it1++) +// (*tnl1).push_back(*it1); +//} +//} + + if ((tnl1 == NULL) && (tnl2 == NULL)) { + + if ((one != NULL) && (two != NULL)) { + + new_list = new SgStatementPtrList; + + (*new_list).push_back(isSgStatement(one)); + (*new_list).push_back(isSgStatement(two)); + + CG_roseRepr* new_rep = new CG_roseRepr(new_list); + + return static_cast(new_rep); + + } else if ((one != NULL) && (two == NULL)) { + + return static_cast(new CG_roseRepr(one)); + + } else if ((two != NULL) && (one == NULL)) { + return static_cast(new CG_roseRepr(two)); + + } + + } else { + if ((tnl2 != NULL) && (tnl1 == NULL)) { + /* for(SgStatementPtrList::iterator it = (*tnl2).begin(); it != (*tnl2).end(); it++) + { + (*tnl1).push_back(*it); + + } + */ + if (one == NULL) + return list2; + else { + new_list = new SgStatementPtrList; + (*new_list).push_back(isSgStatement(one)); + + for (SgStatementPtrList::iterator it = (*tnl2).begin(); + it != (*tnl2).end(); it++) { + (*new_list).push_back(*it); + + } + //delete list2; + return static_cast(new CG_roseRepr(new_list)); + } + } else if ((tnl1 != NULL) && (tnl2 == NULL)) { + if (two == NULL) + return list1; + else { + + (*tnl1).push_back(isSgStatement(two)); + // delete list1; + return static_cast(new CG_roseRepr(tnl1)); + + } + + } else if ((tnl1 != NULL) && (tnl2 != NULL)) { + + for (SgStatementPtrList::iterator it = (*tnl2).begin(); + it != (*tnl2).end(); it++) { + (*tnl1).push_back(*it); + + } + + // delete list2; + // delete list1; + return static_cast(new CG_roseRepr(tnl1)); + } +//else{ +// SgNode* tnll2 = static_cast(list2)->tnl_; +// if(tnll2 != NULL){ +// if(isSgStatement(tnll2)) +// (*tnl1).push_back(isSgStatement(tnll2)); +// else if(isSgScopeStatement(tnll2)){ +// SgStatementPtrList scopeStmtPtrLst1 = isSgScopeStatement(tnll2)->generateStatementList(); + +// for(SgStatementPtrList::iterator it2 = scopeStmtPtrLst1.begin();it2 != scopeStmtPtrLst1.end(); it2++) +// (*tnl1).push_back(*it2); + +// } +//} +// else{ +// SgStatement* stmt2 = isSgStatement(buildExprStatement(static_cast(list2)->op_)); +// (*tnl1).push_back(stmt2); + +// } + +//} + // stmt2 = isSgStatement(tnl2); + +// std::string c = tnl1->unparseToString(); + +// std::string d = isSgNode(stmt2)->unparseToString(); + +// if(isSgForStatement(tnl1) || isSgBasicBlock(tnl1)) +// isSgScopeStatement(tnl1)->append_statement(stmt2); +// else +// { + // stmt1 = isSgStatement(tnl1); + // parent = isSgStatement(tnl1->get_parent()); + // if(isSgForStatement(tnl1->get_parent()) || isSgBasicBlock(tnl1->get_parent())) + // isSgScopeStatement(tnl1->get_parent())->append_statement(stmt2); + // else if (isSgStatement(tnl1->get_parent())) + // isSgStatement(tnl1->get_parent())->insert_statement(stmt1, stmt2, false); + +// } + + } +// delete list2; + +// return list1; + +} + + +CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, CG_outputRepr* arg1, + CG_outputRepr* arg2, CG_outputRepr* arg3) const { + + //SgName type_name("dim3"); + //SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); + // SgClassDeclaration * type_decl = isSgClassDeclaration( + // type_symbol->get_declaration()); + + //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); + + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgName("dim3")); + + SgExprListExp * ctor_args; + if(arg3 != NULL) + ctor_args = buildExprListExp(static_cast(arg1)->op_, + static_cast(arg2)->op_, static_cast(arg3)->op_); + else + ctor_args = buildExprListExp(static_cast(arg1)->op_, + static_cast(arg2)->op_); + SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( + buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); + + char joined_str[20]; + + strcpy(joined_str, "dim3 "); + strcat(joined_str, varName); + + SgExprStatement* decl = buildAssignStatement( + buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), + dim3_func_call); + + SgStatementPtrList *tnl2 = new SgStatementPtrList; + + // (*tnl2).push_back(var_decl); + (*tnl2).push_back(decl); + return new CG_roseRepr(tnl2); + +} + +/*CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, int arg1, + int arg2) const { + + SgName type_name("dim3"); + SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); + SgClassDeclaration * type_decl = isSgClassDeclaration( + type_symbol->get_declaration()); + + //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); + + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgName("dim3")); + + SgExprListExp * ctor_args = buildExprListExp(buildIntVal(arg1), + buildIntVal(arg2)); + + SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( + buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); + + char joined_str[20]; + + strcpy(joined_str, "dim3 "); + strcat(joined_str, varName); + + SgExprStatement* decl = buildAssignStatement( + buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), + dim3_func_call); + + SgStatementPtrList *tnl2 = new SgStatementPtrList; + + // (*tnl2).push_back(var_decl); + (*tnl2).push_back(decl); + return new CG_roseRepr(tnl2); +} + +CG_outputRepr* CG_roseBuilder::CreateDim3(const char* varName, int arg1, + int arg2, int arg3) const { + + SgName type_name("dim3"); + SgClassSymbol * type_symbol = global_scope->lookup_class_symbol(type_name); + SgClassDeclaration * type_decl = isSgClassDeclaration( + type_symbol->get_declaration()); + + //SgVariableDeclaration * var_decl = buildVariableDeclaration(varName, type_symbol->get_type()); + + SgFunctionSymbol * ctor_symbol = global_scope->lookup_function_symbol( + SgName("dim3")); + + SgExprListExp * ctor_args = buildExprListExp(buildIntVal(arg1), + buildIntVal(arg2), buildIntVal(arg3)); + + SgFunctionCallExp * dim3_func_call = buildFunctionCallExp( + buildFunctionRefExp(ctor_symbol->get_declaration()), ctor_args); + + char joined_str[20]; + + strcpy(joined_str, "dim3 "); + strcat(joined_str, varName); + + SgExprStatement* decl = buildAssignStatement( + buildOpaqueVarRefExp(joined_str, isSgScopeStatement(root_)), + dim3_func_call); + + SgStatementPtrList *tnl2 = new SgStatementPtrList; + + // (*tnl2).push_back(var_decl); + (*tnl2).push_back(decl); + return new CG_roseRepr(tnl2); + + + +} +*/ + +/*CG_outputRepr* CG_suifBuilder::CreateKernel(immed_list* iml) const { + instruction *ins = new in_rrr(io_mrk); + ins->append_annote(k_cuda_kernel, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); + } + + type_node* CG_suifBuilder::ModifyType(type_node* base, const char* modifier) const { + modifier_type* result = new modifier_type(TYPE_NULL, base); + immed_list *iml = new immed_list; + iml->append(immed((char*)modifier)); + result->append_annote(k_cuda_modifier, iml); + return result; + } + */ + +std::vector substitute(SgNode *in, const SgVariableSymbol *sym, + SgExpression* expr, SgNode* root) { + + SgStatement* stmt; + SgExpression* op; + std::vector arrays; + + if (in != NULL) { + if (stmt = isSgStatement(in)) { + if (isSgBasicBlock(stmt)) { + SgStatementPtrList& stmts = + isSgBasicBlock(stmt)->get_statements(); + for (int i = 0; i < stmts.size(); i++) { + stmts[i]->set_parent(stmt); + std::vector a = substitute( + isSgNode(stmts[i]), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } else if (isSgForStatement(stmt)) { + SgForStatement *tnf = isSgForStatement(stmt); + tnf->get_for_init_stmt()->set_parent(tnf); + tnf->get_test()->set_parent(tnf); + tnf->get_increment()->set_parent(tnf); + tnf->get_loop_body()->set_parent(tnf); + std::vector a = substitute( + isSgNode(tnf->get_for_init_stmt()), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector a1 = substitute( + isSgNode(tnf->get_test()), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + std::vector a2 = substitute( + isSgNode(tnf->get_increment()), sym, expr, root); + std::copy(a2.begin(), a2.end(), back_inserter(arrays)); + std::vector a3 = substitute( + isSgNode(tnf->get_loop_body()), sym, expr, root); + std::copy(a3.begin(), a3.end(), back_inserter(arrays)); + } else if (isSgFortranDo(stmt)) { // Manu:: fortran support + SgFortranDo *tnf = isSgFortranDo(stmt); + tnf->get_initialization()->set_parent(tnf); + tnf->get_bound()->set_parent(tnf); + tnf->get_increment()->set_parent(tnf); + tnf->get_body()->set_parent(tnf); + std::vector a = substitute( + isSgNode(tnf->get_initialization()), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector a1 = substitute( + isSgNode(tnf->get_bound()), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + std::vector a2 = substitute( + isSgNode(tnf->get_increment()), sym, expr, root); + std::copy(a2.begin(), a2.end(), back_inserter(arrays)); + std::vector a3 = substitute( + isSgNode(tnf->get_body()), sym, expr, root); + std::copy(a3.begin(), a3.end(), back_inserter(arrays)); + } else if (isSgForInitStatement(stmt)) { + + SgStatementPtrList& stmts = + isSgForInitStatement(stmt)->get_init_stmt(); + + for (SgStatementPtrList::iterator it = stmts.begin(); + it != stmts.end(); it++) { + std::vector a = substitute(isSgNode(*it), + sym, expr, root); + + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } + /*else if(isSgFortranDo(stmt)){ + SgFortranDo *tfortran = isSgFortranDo(stmt); + omega::CG_roseRepr *r = new omega::CG_roseRepr(isSgStatement(tfortran->get_body())); + std::vector a = FindArrayRef(r); + delete r; + std::copy(a.begin(), a.end(), back_inserter(arrays)); + }*/ + else if (isSgVariableDeclaration(stmt)) { + if (SgExpression *init = + isSgVariableDeclaration(stmt)->get_variables().front()->get_initializer()) { + if (isSgAssignInitializer(init)) { + std::vector a = substitute( + isSgAssignInitializer(init)->get_operand(), sym, + expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } + } else if (isSgIfStmt(stmt)) { + SgIfStmt* tni = isSgIfStmt(stmt); + //tni->get_conditional()->set_parent(tni); + //tni->get_true_body()->set_parent(tni); + //tni->get_false_body()->set_parent(tni); + std::vector a = substitute( + isSgNode(tni->get_conditional()), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector a1 = substitute( + isSgNode(tni->get_true_body()), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + std::vector a2 = substitute( + isSgNode(tni->get_false_body()), sym, expr, root); + std::copy(a2.begin(), a2.end(), back_inserter(arrays)); + } else if (isSgExprStatement(stmt)) { + (isSgExprStatement(stmt)->get_expression())->set_parent( + isSgExprStatement(stmt)); + std::vector a = substitute( + isSgNode(isSgExprStatement(stmt)->get_expression()), + sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } //end else if + } //end if + else { + op = isSgExpression(in); + // std::string x = isSgNode(op)->unparseToString(); + std::string y = sym->get_name().getString(); +// std::cout << "------substitute else:: " << in->unparseToString().c_str() << ", " << y.c_str() << "\n"; + + if (isSgBinaryOp(op)) { + + isSgBinaryOp(op)->get_lhs_operand()->set_parent(op); + isSgBinaryOp(op)->get_rhs_operand()->set_parent(op); + + std::vector a = substitute( + isSgBinaryOp(op)->get_lhs_operand(), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + std::vector a1 = substitute( + isSgBinaryOp(op)->get_rhs_operand(), sym, expr, root); + std::copy(a1.begin(), a1.end(), back_inserter(arrays)); + } else if (isSgUnaryOp(op)) { + //isSgUnaryOp(op)->get_operand()->set_parent(op); + //std::string x = isSgNode(op)->unparseToString(); + //std::cout< a = substitute( + isSgUnaryOp(op)->get_operand(), sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } else if (isSgVarRefExp(op)) { + std::string z = + isSgVarRefExp(op)->get_symbol()->get_name().getString(); + if (!strcmp(z.c_str(), y.c_str())) { + //isSgVarRefExp(op)->set_symbol(isSgVarRefExp(expr)->get_symbol()); + arrays.push_back(isSgVarRefExp(op)); + //replaceVariableReferences(root, isSgVarRefExp(in)->get_symbol(), temp); + //r = true; + } //end if + } //end else if + else if (isSgCallExpression(op)) { + SgExprListExp* exprs = isSgCallExpression(op)->get_args(); + SgExpressionPtrList &expr_list = exprs->get_expressions(); + + for (SgExpressionPtrList::iterator it = expr_list.begin(); + it != expr_list.end(); it++) { + std::vector a = substitute(isSgNode(*it), + sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + } else if (isSgExprListExp(op)) { // Manu:: fortran indices are stored this way + SgExpressionPtrList &expr_list = isSgExprListExp(op)->get_expressions(); + + for (SgExpressionPtrList::iterator it = expr_list.begin(); + it != expr_list.end(); it++) { + std::vector a = substitute(isSgNode(*it), + sym, expr, root); + std::copy(a.begin(), a.end(), back_inserter(arrays)); + } + + } + + //end else if + //else if(!isSgValueExp(op)) + // throw ir_error("unrecognized expression type"); + } //end else + } //end if + + /* bool r = false; + if (isSgVarRefExp(in) && (isSgVarRefExp(in)->get_symbol() == sym)) { + omega::CG_roseRepr *result = new omega::CG_roseRepr(expr); + SgExpression* expr1 = result->GetExpression(); + delete result; + SgVariableSymbol* temp = isSgVarRefExp(expr1)->get_symbol(); + parent->replace_expression(in, expr1); + replaceVariableReferences(root, isSgVarRefExp(in)->get_symbol(), temp); + r = true; + } + else if(isSgBinaryOp(in)){ + substitute(isSgBinaryOp(in)->get_lhs_operand(), sym, expr, root, in); + substitute(isSgBinaryOp(in)->get_rhs_operand(), sym, expr, root, in); + } + else if(isSgUnaryOp(in)) + substitute(isSgUnaryOp(in)->get_operand(), sym, expr, root, in); + + */ + + return arrays; +} + +/*bool substitute(SgStatement *tn, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab) { + if (tn == NULL) + return false; + + bool r = false; + if( tn != NULL){ + if(isSgExpression(tn)){ + r = substitute(isSgExpression(tn), sym, expr, root, isSgExpression(tn)) || r; + + } + else { + omega::CG_roseRepr *result = new omega::CG_roseRepr(expr); + SgExpression* expr1 = result->GetExpression(); + tn->replace_expression(buildVarRefExp(sym), expr1); + for (unsigned i = 0; i < tn->get_numberOfTraversalSuccessors(); i++) + r = substitute(isSgStatement(tn->get_traversalSuccessorByIndex(i)), sym, expr, root, symtab) || r; + + } + } + return r; + } + + bool substitute(SgNode *tnl, SgVariableSymbol *sym, SgExpression* expr, SgNode* root, SgSymbolTable* symtab) { + if (tnl == NULL) + return false; + + bool r = false; + + for(int i=0; i < tnl->get_numberOfTraversalSuccessors(); i++){ + + SgNode* tn = tnl->get_traversalSuccessorByIndex(i); + r = substitute(isSgStatement(tn), sym, expr, root, symtab) || r; + } + + + return r; + } + */ + +} // namespace diff --git a/omega/code_gen/src/CG_roseRepr.cc b/omega/code_gen/src/CG_roseRepr.cc new file mode 100644 index 0000000..99cf973 --- /dev/null +++ b/omega/code_gen/src/CG_roseRepr.cc @@ -0,0 +1,176 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California. + All Rights Reserved. + + Purpose: + omega holder for suif implementaion + + Notes: + + History: + 02/01/06 - Chun Chen - created +*****************************************************************************/ + +#include +#include +#include +#include +#include +namespace omega { + + + + +CG_roseRepr::CG_roseRepr(): tnl_(NULL), op_(NULL), list_(NULL){ + +} + +CG_roseRepr::CG_roseRepr(SgNode *tnl): tnl_(tnl), op_(NULL),list_(NULL) { +} + +CG_roseRepr::CG_roseRepr(SgExpression* op): tnl_(NULL), op_(op),list_(NULL){ +} +CG_roseRepr::CG_roseRepr(SgStatementPtrList* stmtlist):tnl_(NULL), op_(NULL), list_(stmtlist){ +} + +CG_roseRepr::~CG_roseRepr() { + // delete nothing here. operand or tree_node_list should already be + // grafted to other expression tree or statement list +} + +CG_outputRepr* CG_roseRepr::clone() const { + + if( tnl_ != NULL) { + SgTreeCopy tc; + SgNode *tnl = tnl_->copy(tc); + copyAttributes(tnl_, tnl); + + tnl->set_parent(tnl_->get_parent()); + return new CG_roseRepr(tnl); + } + else if(op_ != NULL) + { + SgTreeCopy tc1; + SgNode* op = isSgNode(op_)->copy(tc1); + copyAttributes(op_, op); + + op->set_parent(isSgNode(op_)->get_parent()); + return new CG_roseRepr(isSgExpression(op)); + } + else if(list_ != NULL) + { + SgStatementPtrList* list2 = new SgStatementPtrList; + + for(SgStatementPtrList::iterator it = (*list_).begin(); it != (*list_).end(); it++){ + SgTreeCopy tc3; + SgNode *tnl2 = isSgNode(*it)->copy(tc3); + copyAttributes(*it, tnl2); + + tnl2->set_parent(isSgNode(*it)->get_parent()); + + (*list2).push_back(isSgStatement(tnl2)); + } + return new CG_roseRepr(list2); + } + + return NULL; +} + +void CG_roseRepr::clear() { + if(tnl_ != NULL) { + delete tnl_; + tnl_ = NULL; + } +} + +SgNode* CG_roseRepr::GetCode() const { + return tnl_; +} + +SgStatementPtrList* CG_roseRepr::GetList() const { + return list_; +} + +SgExpression* CG_roseRepr::GetExpression() const { + return op_; +} +void CG_roseRepr::Dump() const { +SgNode* tnl = tnl_; +SgExpression* op = op_ ; + if(tnl != NULL) + DumpFileHelper(tnl, stdout); + else if(op != NULL) + DumpFileHelper(isSgNode(op), stdout); + +} + +void CG_roseRepr::DumpFileHelper(SgNode* node, FILE *fp) const{ + std::string x; + size_t numberOfSuccessors = node->get_numberOfTraversalSuccessors(); + if(numberOfSuccessors == 0){ + x = node->unparseToString (); + fprintf(fp, "%s", x.c_str()); + } + else{ + for (size_t idx = 0; idx < numberOfSuccessors; idx++) + { + SgNode *child = NULL; + child = node->get_traversalSuccessorByIndex(idx); + DumpFileHelper(child, fp); + } + +} +} + +/*void CG_roseRepr::DumpToFile(FILE *fp) const { +// std::string x; +SgNode* tnl = tnl_; +SgExpression* op = op_ ; + +if(tnl!= NULL){ + std::string x = tnl->unparseToString(); + fprintf(fp, "%s", x.c_str()); + +} +else if(op != NULL){ + std::string x = isSgNode(op)->unparseToString(); + fprintf(fp, "%s", x.c_str()); + + + +} +} +*/ +/* +SgNode* CG_roseRepr::copyAST ( SgNode* node ) +{ + +// This is a better implementation using a derived class from SgCopyHelp to control the +// copying process (skipping the copy of any function definition). This is a variable +// declaration with an explicitly declared class type. +class RestrictedCopyType : public SgCopyHelp + { + // DQ (9/26/2005): This class demonstrates the use of the copy mechanism + // within Sage III (originally designed and implemented by Qing Yi). + // One problem with it is that there is no context information permitted. + + public: + virtual SgNode *copyAst(const SgNode *n) + { + // This is the simpliest possible version of a deep copy SgCopyHelp::copyAst() member function. + SgNode *returnValue = n->copy(*this); + + return returnValue; + } + } restrictedCopyType; + + + + +// This triggers a bug with test2005_152.C (the unparsed code fails for g++ 4.1.2, but not 3.5.6) +SgNode* copyOfNode = node->copy(restrictedCopyType); +return copyOfNode; + +} +*/ +} // namespace diff --git a/omega/code_gen/src/CG_stringBuilder.cc b/omega/code_gen/src/CG_stringBuilder.cc new file mode 100644 index 0000000..2f9286f --- /dev/null +++ b/omega/code_gen/src/CG_stringBuilder.cc @@ -0,0 +1,487 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + generate pseudo string code + + Notes: + There is no need to check illegal NULL parameter and throw invalid_argument + in other IR interface implementation. They are for debugging purpose. + intMod implements modular function that returns positve remainder no matter + lop is postive or nagative and rop is guranteed to be positive here. + + History: + 04/17/96 - Lei Zhou - created + 08/31/09 add parenthesis to string operands, Chun Chen +*****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +namespace { + +std::string SafeguardString(const std::string &s, char op) { + int len = s.length(); + int paren_level = 0; + int num_plusminus = 0; + int num_mul = 0; + int num_div = 0; + for (int i = 0; i < len; i++) + switch (s[i]) { + case '(': + paren_level++; + break; + case ')': + paren_level--; + break; + case '+': + case '-': + if (paren_level == 0) + num_plusminus++; + break; + case '*': + if (paren_level == 0) + num_mul++; + break; + case '/': + if (paren_level == 0) + num_div++; + break; + default: + break; + } + + bool need_paren = false; + switch (op) { + case '-': + if (num_plusminus > 0) + need_paren = true; + break; + case '*': + if (num_plusminus > 0 || num_div > 0) + need_paren = true; + break; + case '/': + if (num_plusminus > 0 || num_div > 0 || num_mul > 0) + need_paren = true; + break; + default: + break; + } + + if (need_paren) + return "(" + s + ")"; + else + return s; +} + + +std::string GetIndentSpaces(int indent) { + std::string indentStr; + for (int i = 1; i < indent; i++) { + indentStr += " "; + } + return indentStr; +} + + +// A shortcut to extract the string enclosed in the CG_outputRepr and delete +// the original holder. +std::string GetString(omega::CG_outputRepr *repr) { + std::string result = static_cast(repr)->GetString(); + delete repr; + return result; +} + +} + + +namespace omega { + + + +//----------------------------------------------------------------------------- +// Class: CG_stringBuilder +//----------------------------------------------------------------------------- + +CG_stringRepr *CG_stringBuilder::CreateSubstitutedStmt(int indent, CG_outputRepr *stmt, + const std::vector &vars, + std::vector &subs) const { + std::string listStr = ""; + + for (int i = 0; i < subs.size(); i++) { + if (subs[i] == NULL) + listStr += "N/A"; + else + listStr += GetString(subs[i]); + if (i < subs.size() - 1) + listStr += ","; + } + + std::string stmtName = GetString(stmt); + std::string indentStr = GetIndentSpaces(indent); + + return new CG_stringRepr(indentStr + stmtName + "(" + listStr + ");\n"); +} + +CG_stringRepr *CG_stringBuilder::CreateAssignment(int indent, + CG_outputRepr *lhs, + CG_outputRepr *rhs) const { + if (lhs == NULL || rhs == NULL) + throw std::invalid_argument("missing lhs or rhs in assignment"); + + std::string lhsStr = GetString(lhs); + std::string rhsStr = GetString(rhs); + + std::string indentStr = GetIndentSpaces(indent); + + return new CG_stringRepr(indentStr + lhsStr + "=" + rhsStr + ";\n"); +} + + +CG_stringRepr *CG_stringBuilder::CreateInvoke(const std::string &funcName, + std::vector &list) const { + std::string listStr = ""; + + for (int i = 0; i < list.size(); i++) { + listStr += GetString(list[i]); + if ( i < list.size()-1) + listStr += ","; + } + + return new CG_stringRepr(funcName + "(" + listStr + ")"); +} + + +CG_stringRepr *CG_stringBuilder::CreateComment(int indent, const std::string &commentText) const { + if (commentText == std::string("")) { + return NULL; + } + + std::string indentStr = GetIndentSpaces(indent); + + return new CG_stringRepr(indentStr + "// " + commentText + "\n"); +} + +CG_stringRepr* CG_stringBuilder::CreateAttribute(CG_outputRepr *control, + const std::string &commentText) const { + if (commentText == std::string("")) { + return static_cast (control); + } + + std::string controlString = GetString(control); + + return new CG_stringRepr("// " + commentText + "\n" + controlString); + +} + +CG_outputRepr* CG_stringBuilder::CreatePragmaAttribute(CG_outputRepr *scopeStmt, int looplevel, const std::string &pragmaText) const { + // -- Not Implemented + return scopeStmt; +} + +CG_outputRepr* CG_stringBuilder::CreatePrefetchAttribute(CG_outputRepr* scopeStmt, int looplevel, const std::string& arrName, int hint) const { + // -- Not Implemented + return scopeStmt; +} + +CG_stringRepr *CG_stringBuilder::CreateIf(int indent, CG_outputRepr *guardList, + CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { + if (guardList == NULL) + throw std::invalid_argument("missing if condition"); + + if (true_stmtList == NULL && false_stmtList == NULL) { + delete guardList; + return NULL; + } + + std::string guardListStr = GetString(guardList); + std::string indentStr = GetIndentSpaces(indent); + std::string s; + if (true_stmtList != NULL && false_stmtList == NULL) { + s = indentStr + "if (" + guardListStr + ") {\n" + + GetString(true_stmtList) + + indentStr + "}\n"; + } + else if (true_stmtList == NULL && false_stmtList != NULL) { + s = indentStr + "if !(" + guardListStr + ") {\n" + + GetString(false_stmtList) + + indentStr + "}\n"; + } + else { + s = indentStr + "if (" + guardListStr + ") {\n" + + GetString(true_stmtList) + + indentStr + "}\n" + + indentStr + "else {\n" + + GetString(false_stmtList) + + indentStr + "}\n"; + } + + return new CG_stringRepr(s); +} + + + +CG_stringRepr *CG_stringBuilder::CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, CG_outputRepr *upper, + CG_outputRepr *step) const { + if (index == NULL) + throw std::invalid_argument("missing loop index"); + if (lower == NULL) + throw std::invalid_argument("missing loop lower bound"); + if (upper == NULL) + throw std::invalid_argument("missing loop upper bound"); + if (step == NULL) + throw std::invalid_argument("missing loop step size"); + + std::string indexStr = GetString(index); + std::string lowerStr = GetString(lower); + std::string upperStr = GetString(upper); + + std::string doStr = "for(" + indexStr + " = " + lowerStr + "; " + + indexStr + " <= " + upperStr + "; " + + indexStr; + + std::string stepStr = GetString(step); + if (stepStr == to_string(1)) + doStr += "++"; + else + doStr += " += " + stepStr; + + doStr += ")"; + + return new CG_stringRepr(doStr); +} + + +CG_stringRepr *CG_stringBuilder::CreateLoop(int indent, CG_outputRepr *control, + CG_outputRepr *stmtList) const { + if (stmtList == NULL) { + delete control; + return NULL; + } + else if (control == NULL) + return static_cast(stmtList); + + std::string ctrlStr = GetString(control); + std::string stmtStr = GetString(stmtList); + + std::string indentStr = GetIndentSpaces(indent); + + std::string s = indentStr + ctrlStr + " {\n" + + stmtStr + + indentStr + "}\n"; + + return new CG_stringRepr(s); +} + + + +CG_stringRepr *CG_stringBuilder::CreateInt(int num) const { + std::string s = to_string(num); + return new CG_stringRepr(s); +} + + + +bool CG_stringBuilder::isInteger(CG_outputRepr *op) const { + + char * cstr; + std::string s = GetString(op); + cstr = new char [s.size()+1]; + strcpy (cstr, s.c_str()); + int count = 0; + while(cstr[count] != '\n' && cstr[count] != '\0' ) + if( !isdigit(cstr[count])) + return false; + + + return true; +} + + + +CG_stringRepr *CG_stringBuilder::CreateIdent(const std::string &varName) const { + if (varName == std::string("")) { + return NULL; + } + + return new CG_stringRepr(varName); +} + + +CG_stringRepr *CG_stringBuilder::CreatePlus(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) { + return static_cast(lop); + } + else if (lop == NULL) { + return static_cast(rop); + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + "+" + ropStr); +} + + +CG_stringRepr *CG_stringBuilder::CreateMinus(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) { + return static_cast(lop); + } + else if (lop == NULL) { + std::string ropStr = GetString(rop); + return new CG_stringRepr("-" + SafeguardString(ropStr, '-')); + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + "-" + SafeguardString(ropStr, '-')); +} + + +CG_stringRepr *CG_stringBuilder::CreateTimes(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) { + delete rop; + delete lop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(SafeguardString(lopStr, '*') + "*" + SafeguardString(ropStr, '*')); +} + + +CG_stringRepr *CG_stringBuilder::CreateDivide(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + throw codegen_error("integer division by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(SafeguardString(lopStr, '/') + "/" + SafeguardString(ropStr, '/')); +} + + +CG_stringRepr *CG_stringBuilder::CreateIntegerFloor(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + throw codegen_error("integer division by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr("intFloor(" + lopStr + "," + ropStr + ")"); +} + + +CG_stringRepr *CG_stringBuilder::CreateIntegerMod(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + throw codegen_error("integer modulo by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr("intMod(" + lopStr + "," + ropStr + ")"); +} + +CG_stringRepr *CG_stringBuilder::CreateIntegerCeil(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == 0) + throw codegen_error("integer ceiling by zero"); + else if (lop == NULL) { + delete rop; + return NULL; + } + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr("intCeil(" + lopStr + "," + ropStr + ")"); +} + + +CG_stringRepr *CG_stringBuilder::CreateAnd(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL) + return static_cast(lop); + else if (lop == NULL) + return static_cast(rop); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " && " + ropStr); +} + + +CG_stringRepr *CG_stringBuilder::CreateGE(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) + throw std::invalid_argument("missing operand in greater than equal comparison condition"); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " >= " + ropStr); +} + + + +CG_stringRepr *CG_stringBuilder::CreateLE(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) + throw std::invalid_argument("missing operand in less than equal comparison condition"); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " <= " + ropStr); +} + + + +CG_stringRepr *CG_stringBuilder::CreateEQ(CG_outputRepr *lop, CG_outputRepr *rop) const { + if (rop == NULL || lop == NULL) + throw std::invalid_argument("missing operand in equal comparison condition"); + + std::string lopStr = GetString(lop); + std::string ropStr = GetString(rop); + + return new CG_stringRepr(lopStr + " == " + ropStr); +} + + + +CG_stringRepr *CG_stringBuilder::StmtListAppend(CG_outputRepr *list1, CG_outputRepr *list2) const { + if (list2 == NULL) { + return static_cast(list1); + } + else if (list1 == NULL) { + return static_cast(list2); + } + + std::string list1Str = GetString(list1); + std::string list2Str = GetString(list2); + + return new CG_stringRepr(list1Str + list2Str); +} + +} diff --git a/omega/code_gen/src/CG_stringRepr.cc b/omega/code_gen/src/CG_stringRepr.cc new file mode 100644 index 0000000..63a1657 --- /dev/null +++ b/omega/code_gen/src/CG_stringRepr.cc @@ -0,0 +1,54 @@ +/***************************************************************************** + Copyright (C) 1994-2000 University of Maryland + Copyright (C) 2008 University of Southern California + Copyright (C) 2009 University of Utah + All Rights Reserved. + + Purpose: + omega holder for string implementation. + + Notes: + + History: + 04/17/96 - Lei Zhou - created +*****************************************************************************/ + +#include +#include + +namespace omega { + +CG_stringRepr::CG_stringRepr() { +} + +CG_stringRepr::CG_stringRepr(const std::string& _s) : s(_s) { +} + +CG_stringRepr::~CG_stringRepr() { +} + +CG_outputRepr* CG_stringRepr::clone() { + return new CG_stringRepr(s); +} + + +//----------------------------------------------------------------------------- +// basic operation +//----------------------------------------------------------------------------- +std::string CG_stringRepr::GetString() const { + return s; +} + + +//----------------------------------------------------------------------------- +// Dump operations +//----------------------------------------------------------------------------- +void CG_stringRepr::Dump() const { + printf("%s\n", s.c_str()); +} + +void CG_stringRepr::DumpToFile(FILE *fp) const { + fprintf(fp,"%s", s.c_str()); +} + +} // namespace diff --git a/omega/code_gen/src/CG_suifBuilder.cc b/omega/code_gen/src/CG_suifBuilder.cc new file mode 100644 index 0000000..6bb91b7 --- /dev/null +++ b/omega/code_gen/src/CG_suifBuilder.cc @@ -0,0 +1,678 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + generate suif code for omega + + Notes: + + History: + 02/01/06 created by Chun Chen +*****************************************************************************/ + +#include +#include +#include +#include + +namespace omega { + +//----------------------------------------------------------------------------- +// make suif initilization happy +//----------------------------------------------------------------------------- +char *k_ocg_comment; +char *k_s2c_pragma; +char *k_cuda_dim3; +char *k_cuda_kernel; +char *k_cuda_modifier; +char *k_cuda_texture_memory; //protonu--added to track texture memory type + +// void __attribute__ ((constructor)) my_init(void) { +// ANNOTE(k_ocg_comment, "omega_comment", TRUE); +// } + +//protonu--extern decls +//protonu--adding stuff to make Chun's code work with Gabe's +extern Tuple< Tuple > smtNonSplitLevels; +extern Tuple< Tuple > loopIdxNames;//per stmt +extern std::vector< std::pair > syncs; +extern int checkLoopLevel; +extern int stmtForLoopCheck; +extern int upperBoundForLevel; +extern int lowerBoundForLevel; +extern bool fillInBounds; + + +const char *libcode_gen_ver_string = ""; +const char *libcode_gen_who_string = ""; +const char *libcode_gen_suif_string = ""; + + +void init_code_gen() { + static bool isInit = false; + if(!isInit) + { + isInit = true; + ANNOTE(k_ocg_comment, "omega_comment", TRUE); + ANNOTE(k_s2c_pragma, "s2c pragma", TRUE); + ANNOTE(k_cuda_dim3, "cuda dim3", TRUE); + ANNOTE(k_cuda_kernel, "cuda kernel", TRUE); + ANNOTE(k_cuda_modifier, "cuda modifier", TRUE); + } +} + + +void exit_code_gen(void) { +} + + +//----------------------------------------------------------------------------- +// Class: CG_suifBuilder +//----------------------------------------------------------------------------- + +CG_suifBuilder::CG_suifBuilder(proc_symtab *symtab) +{ + symtab_ = symtab; + init_code_gen(); +} + +CG_outputRepr* CG_suifBuilder::CreatePlaceHolder (int, CG_outputRepr *stmt, + Tuple &funcList, Tuple &loop_vars) const { + tree_node_list *tnl = static_cast(stmt)->tnl_; + delete stmt; + + for (int i = 1; i <= funcList.size(); i++) { + if (funcList[i] == NULL) + continue; + + CG_suifRepr *repr = static_cast(funcList[i]); + operand op = repr->op_; + delete repr; + + var_sym *vs = static_cast(symtab_->lookup_sym(loop_vars[i].c_str(), SYM_VAR)); + + substitute(tnl, vs, op, symtab_); + + if (op.is_instr()) + delete op.instr(); + } + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateAssignment(int, CG_outputRepr *lhs, + CG_outputRepr *rhs) const { + if ( lhs == NULL || rhs == NULL ) { + fprintf(stderr, "Code generation: Missing lhs or rhs\n"); + return NULL; + } + + operand src = static_cast(rhs)->op_; + if (src.is_instr() && src.instr()->opcode() == io_array) { + in_array *ia = static_cast(src.instr()); + instruction *ins = new in_rrr(io_lod, ia->elem_type(), operand(), ia); + src = operand(ins); + } + + instruction *ins; + operand dst = static_cast(lhs)->op_; + if (dst.is_instr() && dst.instr()->opcode() == io_array) { + in_array *ia = static_cast(dst.instr()); + ins = new in_rrr(io_str, type_void, operand(), operand(ia), src); + } + else + ins = new in_rrr(io_cpy, src.type(), dst, src); + + delete lhs; + delete rhs; + + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateInvoke(const std::string &fname, + Tuple &list) const { + if (fname == std::string("max") || fname == std::string("min")) { + if (list.size() == 0) { + return NULL; + } + else if (list.size() == 1) { + return list[1]; + } + else { + int last = list.size(); + operand op2 = static_cast(list[last])->op_; + delete list[last]; + list.delete_last(); + CG_suifRepr *repr = static_cast(CreateInvoke(fname, list)); + operand op1 = repr->op_; + + instruction *ins; + if (fname == std::string("max")) + ins = new in_rrr(io_max, op1.type(), operand(), op1, op2); + else + ins = new in_rrr(io_min, op1.type(), operand(), op1, op2); + + repr->op_ = operand(ins); + + return repr; + } + } + else { + fprintf(stderr, "Code generation: invoke function io_call not implemented\n"); + return NULL; + } +} + + +CG_outputRepr* CG_suifBuilder::CreateAttribute(CG_outputRepr *control, + const std::string &commentText)const { + if (commentText == std::string("")) { + return control; + } + + instruction *ins = new in_rrr(io_mrk); + + immed_list *iml = new immed_list; + iml->append(immed(const_cast(commentText.c_str()))); + ins->prepend_annote(k_ocg_comment, iml); + + tree_node_list *tnl ; + tnl = static_cast(control)->tnl_; + tnl->append(new tree_instr(ins)); + + + return new CG_suifRepr(tnl); + + +} + + + +CG_outputRepr* CG_suifBuilder::CreateComment(int, const std::string &commentText) const { + if ( commentText == std::string("") ) { + return NULL; + } + + instruction *ins = new in_rrr(io_mrk); + + immed_list *iml = new immed_list; + iml->append(immed(const_cast(commentText.c_str()))); + ins->prepend_annote(k_ocg_comment, iml); + + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateIf(int, CG_outputRepr *guardList, + CG_outputRepr *true_stmtList, CG_outputRepr *false_stmtList) const { + static int if_counter = 1; + std::string s = std::string("omegaif_")+to_string(if_counter++); + label_sym *if_label = new label_sym(const_cast(s.c_str())); + symtab_->add_sym(if_label); + + if ( true_stmtList == NULL && false_stmtList == NULL ) { + delete guardList; + return NULL; + } + else if ( guardList == NULL ) { + return StmtListAppend(true_stmtList, false_stmtList); + } + + tree_node_list *header = new tree_node_list; + operand op = static_cast(guardList)->op_; + + std::stack S; + S.push(op.instr()); + while(!S.empty()) { + instruction *ins = static_cast(S.top()); + S.pop(); + if (ins->opcode() == io_and) { + instruction *ins1 = ins->src_op(0).instr(); + ins1->remove(); + S.push(ins1); + instruction *ins2 = ins->src_op(1).instr(); + ins2->remove(); + S.push(ins2); + delete ins; + } + else { + ins = new in_bj(io_bfalse, if_label, operand(ins)); + header->append(new tree_instr(ins)); + } + } + + tree_node_list *then_part, *else_part; + if (true_stmtList != NULL) + then_part = static_cast(true_stmtList)->tnl_; + else + then_part = NULL; + if (false_stmtList != NULL) + else_part = static_cast(false_stmtList)->tnl_; + else + else_part = NULL; + tree_if *ti = new tree_if(if_label, header, then_part, else_part); + + tree_node_list *tnl = new tree_node_list; + tnl->append(ti); + + delete guardList; + delete true_stmtList; + delete false_stmtList; + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateInductive(CG_outputRepr *index, + CG_outputRepr *lower, + CG_outputRepr *upper, + CG_outputRepr *step) const { + if ( index == NULL || lower == NULL || upper == NULL ) { + fprintf(stderr, "Code generation: something wrong in CreateInductive\n"); + return NULL; + } + + if (step == NULL) + step = CreateInt(1); + + var_sym *index_sym = static_cast(index)->op_.symbol(); + operand lower_bound = static_cast(lower)->op_; + operand upper_bound = static_cast(upper)->op_; + operand step_size = static_cast(step)->op_; + + label_sym *contLabel = new label_sym(""); + label_sym *brkLabel = new label_sym(""); + symtab_->add_sym(contLabel); + symtab_->add_sym(brkLabel); + tree_for *tf = new tree_for(index_sym, FOR_SLTE, contLabel, brkLabel, NULL, + lower_bound, upper_bound, step_size, NULL); + + tree_node_list *tnl = new tree_node_list; + tnl->append(tf); + + delete index; + delete lower; + delete upper; + delete step; + + return new CG_suifRepr(tnl); +} + + +CG_outputRepr* CG_suifBuilder::CreateLoop(int, CG_outputRepr *control, + CG_outputRepr *stmtList) const { + if ( stmtList == NULL ) { + delete control; + return NULL; + } + else if ( control == NULL ) { + fprintf(stderr, "Code generation: no inductive for this loop\n"); + return stmtList; + } + + tree_node_list *tnl = static_cast(control)->tnl_; + tree_node_list_iter iter(tnl); + tree_for *tf = static_cast(iter.step()); + + tree_node_list *body = static_cast(stmtList)->tnl_; + tf->set_body(body); + + delete stmtList; + + return control; +} + + +CG_outputRepr* CG_suifBuilder::CreateInt(int _i) const { + in_ldc *ins = new in_ldc(type_s32, operand(), immed(_i)); + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateIdent(const std::string &_s) const { + if ( &_s == NULL || _s == std::string("") ) { + return NULL; + } + + var_sym *vs = static_cast(symtab_->lookup_sym(_s.c_str(), SYM_VAR)); + + if (vs == NULL) { + vs = new var_sym(type_s32, const_cast(_s.c_str())); + symtab_->add_sym(vs); + } + + return new CG_suifRepr(operand(vs)); +} + + +CG_outputRepr* CG_suifBuilder::CreatePlus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL ) { + return lop; + } + else if ( lop == NULL ) { + return rop; + } + + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + instruction *ins = new in_rrr(io_add, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateMinus(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL ) { + return lop; + } + else if ( lop == NULL ) { + operand op = static_cast(rop)->op_; + instruction *ins = new in_rrr(io_neg, op.type(), operand(), op); + + delete rop; + + return new CG_suifRepr(operand(ins)); + } + else { + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + instruction *ins = new in_rrr(io_sub, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); + } +} + + +CG_outputRepr* CG_suifBuilder::CreateTimes(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL) { + if (rop != NULL) { + rop->clear(); + delete rop; + } + if (lop != NULL) { + lop->clear(); + delete lop; + } + return NULL; + } + + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + instruction *ins = new in_rrr(io_mul, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateIntegerDivide(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL ) { + fprintf(stderr, "Code generation: divide by NULL\n"); + return NULL; + } + else if ( lop == NULL ) { + delete rop; + return NULL; + } + + // (6+5)*10 / 4 + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + // bugs in SUIF prevent use of correct io_divfloor + instruction *ins = new in_rrr(io_div, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateIntegerMod(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL ) { + return NULL; + } + + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + // bugs in SUIF prevent use of correct io_mod + instruction *ins = new in_rrr(io_rem, type_s32, operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateAnd(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if (rop == NULL) + return lop; + else if (lop == NULL) + return rop; + + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + instruction *ins = new in_rrr(io_and, op1.type(), operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateGE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + return CreateLE(rop, lop); +} + + +CG_outputRepr* CG_suifBuilder::CreateLE(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL ) { + return NULL; + } + + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + instruction *ins = new in_rrr(io_sle, type_s32, operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + +CG_outputRepr* CG_suifBuilder::CreateEQ(CG_outputRepr *lop, + CG_outputRepr *rop) const { + if ( rop == NULL || lop == NULL ) { + return NULL; + } + + operand op1 = static_cast(lop)->op_; + operand op2 = static_cast(rop)->op_; + + instruction *ins = new in_rrr(io_seq, type_s32, operand(), op1, op2); + + delete lop; + delete rop; + + return new CG_suifRepr(operand(ins)); +} + + + +CG_outputRepr* CG_suifBuilder::StmtListAppend(CG_outputRepr *list1, + CG_outputRepr *list2) const { + if ( list2 == NULL ) { + return list1; + } + else if ( list1 == NULL ) { + return list2; + } + + tree_node_list *tnl1 = static_cast(list1)->tnl_; + tree_node_list *tnl2 = static_cast(list2)->tnl_; + if (tnl2 == NULL) + tnl1->append(new tree_instr(static_cast(list2)->op_.instr())); + else + tnl1->append(tnl2); + + delete list2; + + return list1; +} + +//protonu--Gabe's stuff added here +//----------------------------------------------------------------------------- +// pragma generation +// TODO: Could allow for a immed_list* instead of a String for strongly typed prgma args +//----------------------------------------------------------------------------- +CG_outputRepr* CG_suifBuilder::CreatePragma(int, + const std::string &pragmaText) const { + if ( pragmaText == std::string("") ) { + return NULL; + } + instruction *ins = new in_rrr(io_mrk); + immed_list *iml = new immed_list; + iml->append(immed(const_cast(pragmaText.c_str()))); + ins->append_annote(k_s2c_pragma, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +CG_outputRepr* CG_suifBuilder::CreateDim3(immed varName, immed arg1, immed arg2) const { + instruction *ins = new in_rrr(io_mrk); + immed_list *iml = new immed_list; + iml->append(immed(varName)); + iml->append(arg1); + iml->append(arg2); + ins->append_annote(k_cuda_dim3, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +CG_outputRepr* CG_suifBuilder::CreateDim3(immed varName, immed arg1, immed arg2, immed arg3) const { + instruction *ins = new in_rrr(io_mrk); + immed_list *iml = new immed_list; + iml->append(immed(varName)); + iml->append(arg1); + iml->append(arg2); + iml->append(arg3); + ins->append_annote(k_cuda_dim3, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +CG_outputRepr* CG_suifBuilder::CreateKernel(immed_list* iml) const { + instruction *ins = new in_rrr(io_mrk); + ins->append_annote(k_cuda_kernel, iml); + tree_node_list *tnl = new tree_node_list; + tnl->append(new tree_instr(ins)); + return new CG_suifRepr(tnl); +} + +type_node* CG_suifBuilder::ModifyType(type_node* base, const char* modifier) const { + modifier_type* result = new modifier_type(TYPE_NULL, base); + immed_list *iml = new immed_list; + iml->append(immed((char*)modifier)); + result->append_annote(k_cuda_modifier, iml); + return result; +} +//end-protonu + + +//----------------------------------------------------------------------------- +// suif utility +//----------------------------------------------------------------------------- + +bool substitute(instruction *in, var_sym *sym, operand expr, base_symtab *st) { + if (in == NULL || sym == NULL) + return false; + + bool r = false; + for (unsigned i = 0; i < in->num_srcs(); i++) { + operand op(in->src_op(i)); + + if (op.is_symbol() && op.symbol() == sym) { + in->set_src_op(i, expr.clone(st)); + r = true; + } + else if (op.is_instr()) { + r = substitute(op.instr(), sym, expr, st) || r; + } + } + + return r; +} + +bool substitute(tree_node *tn, var_sym *sym, operand expr, base_symtab *st) { + if (tn == NULL) + return false; + + bool r = false; + if (tn->kind() == TREE_INSTR) + r = substitute(static_cast(tn)->instr(), sym, expr, st) || r; + else { + for (unsigned i = 0; i < tn->num_child_lists(); i++) { + r = substitute(tn->child_list_num(i), sym, expr, st) || r; + } + } + + return r; +} + +bool substitute(tree_node_list *tnl, var_sym *sym, operand expr, + base_symtab *st) { + if (tnl == NULL) + return false; + + bool r = false; + tree_node_list_iter iter(tnl); + while (!iter.is_empty()) { + tree_node *tn = iter.step(); + + r = substitute(tn, sym, expr, st) || r; + } + + return r; +} + +} diff --git a/omega/code_gen/src/CG_suifRepr.cc b/omega/code_gen/src/CG_suifRepr.cc new file mode 100644 index 0000000..f4f987d --- /dev/null +++ b/omega/code_gen/src/CG_suifRepr.cc @@ -0,0 +1,81 @@ +/***************************************************************************** + Copyright (C) 2008 University of Southern California. + All Rights Reserved. + + Purpose: + omega holder for suif implementaion + + Notes: + + History: + 02/01/06 - Chun Chen - created +*****************************************************************************/ + +#include +#include + +namespace omega { + +CG_suifRepr::CG_suifRepr(): tnl_(NULL), op_() { +} + +CG_suifRepr::CG_suifRepr(tree_node_list *tnl): tnl_(tnl),op_() { +} + +CG_suifRepr::CG_suifRepr(operand op): tnl_(NULL), op_(op) { +} + +CG_suifRepr::~CG_suifRepr() { + // delete nothing here. operand or tree_node_list should already be + // grafted to other expression tree or statement list +} + +CG_outputRepr* CG_suifRepr::clone() { + if (!op_.is_null() ) { + operand op = op_.clone(); + return new CG_suifRepr(op); + } + else if (tnl_ != NULL) { + tree_node_list *tnl = tnl_->clone(); + return new CG_suifRepr(tnl); + } + else + return new CG_suifRepr(); +} + +void CG_suifRepr::clear() { + if (!op_.is_null()) { + if (op_.is_instr()) + delete op_.instr(); + op_.set_null(); + } + else if (tnl_ != NULL) { + delete tnl_; + tnl_ = NULL; + } +} + +tree_node_list* CG_suifRepr::GetCode() const { + return tnl_; +} + +operand CG_suifRepr::GetExpression() const { + return op_; +} + +void CG_suifRepr::Dump() const { + if (tnl_ != NULL) + tnl_->print(); + else if (!op_.is_null()) + op_.print(); +} + +void CG_suifRepr::DumpToFile(FILE *fp) const { + if (tnl_ != NULL) + tnl_->print(fp); + else if (!op_.is_null()) + op_.print(fp); +} + + +} // namespace diff --git a/omega/code_gen/src/CG_utils.cc b/omega/code_gen/src/CG_utils.cc new file mode 100755 index 0000000..d3a5f71 --- /dev/null +++ b/omega/code_gen/src/CG_utils.cc @@ -0,0 +1,1735 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + Utility functions for processing CG tree. + + Notes: + + History: + 07/19/07 when generating output variable substitutions for a mapping + relation, map it to each output to get correct equality, -chun + 07/29/10 when translating equality to assignment, generate appropriate + if-condition when necesssary, -chun +*****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +namespace omega { + +int checkLoopLevel; +int stmtForLoopCheck; +int upperBoundForLevel; +int lowerBoundForLevel; +bool fillInBounds; + +//trick to static init checkLoopLevel to 0 +class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} }; +static JunkStaticInit junkInitInstance__; + + + + +namespace { + +Relation find_best_guard(const Relation &R, const BoolSet<> &active, const std::map &guards) { + std::pair best_cost = std::make_pair(0, 0); + Relation best_cond = Relation::True(R.n_set()); + + Relation r = copy(R); + int max_iter_count = 2*(r.single_conjunct()->n_EQs()) + r.single_conjunct()->n_GEQs(); + int iter_count = 0; + while (!r.is_obvious_tautology()) { + std::pair cost = std::make_pair(0, 0); + Relation cond = pick_one_guard(r); + Relation complement_cond = Complement(copy(cond)); + complement_cond.simplify(); + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + std::map::const_iterator j = guards.find(*i); + if (j == guards.end()) + continue; + if (Must_Be_Subset(copy(j->second), copy(cond))) + cost.first++; + else if (Must_Be_Subset(copy(j->second), copy(complement_cond))) + cost.second++; + } + if (cost > best_cost) { + best_cost = cost; + best_cond = copy(cond); + } + r = Gist(r, cond, 1); + + if (iter_count > max_iter_count) + throw codegen_error("guard condition too complex to handle"); + + iter_count++; + } + + return best_cond; +} + + +Relation find_best_guard(const Relation &R, const std::vector &loops, int start, int end) { + std::pair best_cost = std::make_pair(0, 0); + Relation best_cond = Relation::True(R.n_set()); + + Relation r = copy(R); + int max_iter_count = 2*(r.single_conjunct()->n_EQs()) + r.single_conjunct()->n_GEQs(); + int iter_count = 0; + while (!r.is_obvious_tautology()) { + std::pair cost = std::make_pair(0, 0); + Relation cond = pick_one_guard(r); + int i = start; + for ( ; i < end; i++) { + if (Must_Be_Subset(copy(loops[i]->guard_), copy(cond))) + cost.first++; + else + break; + } + Relation complement_cond = Complement(copy(cond)); + complement_cond.simplify(); + for (int j = i; j < end; j++) + if (Must_Be_Subset(copy(loops[j]->guard_), copy(complement_cond))) + cost.second++; + else + break; + + if (cost > best_cost) { + best_cost = cost; + best_cond = copy(cond); + } + r = Gist(r, cond, 1); + + if (iter_count > max_iter_count) + throw codegen_error("guard condition too complex to handle"); + + iter_count++; + } + + return best_cond; +} + +} + +bool bound_must_hit_stride(const GEQ_Handle &inequality, Variable_ID v, const EQ_Handle &stride_eq, Variable_ID wc, const Relation &bounds, const Relation &known) { + assert(inequality.get_coef(v) != 0 && abs(stride_eq.get_coef(v)) == 1 && wc->kind() == Wildcard_Var && abs(stride_eq.get_coef(wc)) > 1); + + // if bound expression uses floor operation, bail out for now + // TODO: in the future, handle this + if (abs(inequality.get_coef(v)) != 1) + return false; + + coef_t stride = abs(stride_eq.get_coef(wc)); + + Relation r1(known.n_set()); + F_Exists *f_exists1 = r1.add_and()->add_exists(); + F_And *f_root1 = f_exists1->add_and(); + std::map exists_mapping1; + EQ_Handle h1 = f_root1->add_EQ(); + Relation r2(known.n_set()); + F_Exists *f_exists2 = r2.add_and()->add_exists(); + F_And *f_root2 = f_exists2->add_and(); + std::map exists_mapping2; + EQ_Handle h2 = f_root2->add_EQ(); + for (Constr_Vars_Iter cvi(inequality); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h1.update_coef(r1.input_var(v->get_position()), cvi.curr_coef()); + h2.update_coef(r2.input_var(v->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v1, v2; + if (g->arity() == 0) { + v1 = r1.get_local(g); + v2 = r2.get_local(g); + } + else { + v1 = r1.get_local(g, v->function_of()); + v2 = r2.get_local(g, v->function_of()); + } + h1.update_coef(v1, cvi.curr_coef()); + h2.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + Variable_ID v1 = replicate_floor_definition(bounds, v, r1, f_exists1, f_root1, exists_mapping1); + Variable_ID v2 = replicate_floor_definition(bounds, v, r2, f_exists2, f_root2, exists_mapping2); + h1.update_coef(v1, cvi.curr_coef()); + h2.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h1.update_const(inequality.get_const()); + h1.update_coef(f_exists1->declare(), stride); + h2.update_const(inequality.get_const()); + r1.simplify(); + r2.simplify(); + + Relation all_known = Intersection(copy(bounds), copy(known)); + all_known.simplify(); + + if (Gist(r1, copy(all_known), 1).is_obvious_tautology()) { + Relation r3(known.n_set()); + F_Exists *f_exists3 = r3.add_and()->add_exists(); + F_And *f_root3 = f_exists3->add_and(); + std::map exists_mapping3; + EQ_Handle h3 = f_root3->add_EQ(); + for (Constr_Vars_Iter cvi(stride_eq); cvi; cvi++) { + Variable_ID v= cvi.curr_var(); + switch (v->kind()) { + case Input_Var: + h3.update_coef(r3.input_var(v->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v3; + if (g->arity() == 0) + v3 = r3.get_local(g); + else + v3 = r3.get_local(g, v->function_of()); + h3.update_coef(v3, cvi.curr_coef()); + break; + } + case Wildcard_Var: + if (v == wc) + h3.update_coef(f_exists3->declare(), cvi.curr_coef()); + else { + Variable_ID v3 = replicate_floor_definition(bounds, v, r3, f_exists3, f_root3, exists_mapping3); + h3.update_coef(v3, cvi.curr_coef()); + } + break; + default: + assert(false); + } + } + h3.update_const(stride_eq.get_const()); + r3.simplify(); + + if (Gist(r3, Intersection(r2, all_known), 1).is_obvious_tautology()) + return true; + else + return false; + } + else + return false; +} + + +// +// output variable by its name, however if this variable need to be substituted, +// return the substitution. +// +CG_outputRepr *output_ident(CG_outputBuilder *ocg, const Relation &R, Variable_ID v, const std::vector > &assigned_on_the_fly) { + const_cast(R).setup_names(); // hack + + if (v->kind() == Input_Var) { + int pos = v->get_position(); + if (assigned_on_the_fly[pos-1].first != NULL) + return assigned_on_the_fly[pos-1].first->clone(); + else + return ocg->CreateIdent(v->name()); + } + else if (v->kind() == Global_Var) { + if (v->get_global_var()->arity() == 0) + return ocg->CreateIdent(v->name()); + else { + /* This should be improved to take into account the possible elimination + of the set variables. */ + int arity = v->get_global_var()->arity(); + std::vector argList; + for(int i = 1; i <= arity; i++) + argList.push_back(ocg->CreateIdent(const_cast(R).input_var(i)->name())); + CG_outputRepr *call = ocg->CreateInvoke(v->get_global_var()->base_name(), argList); + return call; + } + } + else + assert(false); +} + + +// +// return pair > +// +std::pair > output_assignment(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector > &assigned_on_the_fly) { + Variable_ID v = const_cast(R).set_var(level); + Conjunct *c = const_cast(R).single_conjunct(); + + std::pair result = find_simplest_assignment(R, v, assigned_on_the_fly); + + if (result.second == INT_MAX) + return std::make_pair(static_cast(NULL), std::make_pair(static_cast(NULL), INT_MAX)); + + CG_outputRepr *if_repr = NULL; + CG_outputRepr *assign_repr = NULL; + // check whether to generate if-conditions from equality constraints + if (abs(result.first.get_coef(v)) != 1) { + Relation r(R.n_set()); + F_Exists *f_exists = r.add_and()->add_exists(); + F_And *f_root = f_exists->add_and(); + std::map exists_mapping; + exists_mapping[v] = f_exists->declare(); + + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(result.first); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Input_Var: { + if (cvi.curr_var() == v) + h.update_coef(exists_mapping[v], cvi.curr_coef()); + else + h.update_coef(r.set_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find(cvi.curr_var()); + Variable_ID v2; + if (p == exists_mapping.end()) { + v2 = f_exists->declare(); + exists_mapping[cvi.curr_var()] = v2; + } + else + v2 = p->second; + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + h.update_const(result.first.get_const()); + + for (EQ_Iterator e(c->EQs()); e; e++) + if (!((*e) == result.first)) { + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Input_Var: { + assert(cvi.curr_var() != v); + h.update_coef(r.set_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find(cvi.curr_var()); + Variable_ID v2; + if (p == exists_mapping.end()) { + v2 = f_exists->declare(); + exists_mapping[cvi.curr_var()] = v2; + } + else + v2 = p->second; + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + h.update_const((*e).get_const()); + } + + for (GEQ_Iterator e(c->GEQs()); e; e++) { + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Input_Var: { + h.update_coef(r.set_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find(cvi.curr_var()); + Variable_ID v2; + if (p == exists_mapping.end()) { + v2 = f_exists->declare(); + exists_mapping[cvi.curr_var()] = v2; + } + else + v2 = p->second; + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + h.update_const((*e).get_const()); + } + + r.simplify(); + if (!Gist(r, copy(known), 1).is_obvious_tautology()) { + CG_outputRepr *lhs = output_substitution_repr(ocg, result.first, v, false, R, assigned_on_the_fly); + if_repr = ocg->CreateEQ(ocg->CreateIntegerMod(lhs->clone(), ocg->CreateInt(abs(result.first.get_coef(v)))), ocg->CreateInt(0)); + assign_repr = ocg->CreateDivide(lhs, ocg->CreateInt(abs(result.first.get_coef(v)))); + } + else + assign_repr = output_substitution_repr(ocg, result.first, v, true, R, assigned_on_the_fly); + } + else + assign_repr = output_substitution_repr(ocg, result.first, v, true, R, assigned_on_the_fly); + + if (assign_repr == NULL) + assign_repr = ocg->CreateInt(0); + + return std::make_pair(if_repr, std::make_pair(assign_repr, result.second)); +} + + +// +// return NULL if 0 +// +CG_outputRepr *output_substitution_repr(CG_outputBuilder *ocg, const EQ_Handle &equality, Variable_ID v, bool apply_v_coef, const Relation &R, const std::vector > &assigned_on_the_fly) { + const_cast(R).setup_names(); // hack + + coef_t a = equality.get_coef(v); + assert(a != 0); + + CG_outputRepr *repr = NULL; + for (Constr_Vars_Iter cvi(equality); cvi; cvi++) + if (cvi.curr_var() != v) { + CG_outputRepr *t; + if (cvi.curr_var()->kind() == Wildcard_Var) { + std::pair result = find_floor_definition(R, cvi.curr_var()); + if (!result.first) { + delete repr; + throw codegen_error("can't output non floor defined wildcard"); + } + t = output_inequality_repr(ocg, result.second, cvi.curr_var(), R, assigned_on_the_fly); + } + else + t = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + + if (a > 0) { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { // coef < 0 + if (coef == -1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + else { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { // coef < 0 + if (coef == -1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + } + + int c = equality.get_const(); + if (a > 0) { + if (c > 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(c)); + else if (c < 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(-c)); + } + else { + if (c > 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(c)); + else if (c < 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(-c)); + } + + if (apply_v_coef && abs(a) != 1) + repr = ocg->CreateDivide(repr, ocg->CreateInt(abs(a))); + + return repr; +} + + +// +// original Substitutions class from omega can't handle integer +// division, this is new way. +// +std::vector output_substitutions(CG_outputBuilder *ocg, const Relation &R, const std::vector > &assigned_on_the_fly) { + std::vector subs; + + for (int i = 1; i <= R.n_out(); i++) { + Relation mapping(R.n_out(), 1); + F_And *f_root = mapping.add_and(); + EQ_Handle h = f_root->add_EQ(); + h.update_coef(mapping.output_var(1), 1); + h.update_coef(mapping.input_var(i), -1); + Relation r = Composition(mapping, copy(R)); + r.simplify(); + + Variable_ID v = r.output_var(1); + CG_outputRepr *repr = NULL; + std::pair result = find_simplest_assignment(r, v, assigned_on_the_fly); + if (result.second < INT_MAX) + repr = output_substitution_repr(ocg, result.first, v, true, r, assigned_on_the_fly); + else { + std::pair result = find_floor_definition(R, v); + if (result.first) + try { + repr = output_inequality_repr(ocg, result.second, v, R, assigned_on_the_fly); + } + catch (const codegen_error &) { + } + } + + subs.push_back(repr); + } + + return subs; +} + + +// +// handle floor definition wildcards in equality, the second in returned pair +// is the cost. +// +std::pair find_simplest_assignment(const Relation &R, Variable_ID v, const std::vector > &assigned_on_the_fly) { + Conjunct *c = const_cast(R).single_conjunct(); + + int min_cost = INT_MAX; + EQ_Handle eq; + for (EQ_Iterator e(c->EQs()); e; e++) + if (!(*e).has_wildcards() && (*e).get_coef(v) != 0) { + int cost = 0; + + if (abs((*e).get_coef(v)) != 1) + cost += 4; // divide cost + + int num_var = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var() != v) { + num_var++; + if (abs(cvi.curr_coef()) != 1) + cost += 2; // multiply cost + if (cvi.curr_var()->kind() == Global_Var && cvi.curr_var()->get_global_var()->arity() > 0) + cost += 10; // function cost + else if (cvi.curr_var()->kind() == Input_Var && + assigned_on_the_fly.size() >= cvi.curr_var()->get_position() && + assigned_on_the_fly[cvi.curr_var()->get_position()-1].first != NULL) + cost += assigned_on_the_fly[cvi.curr_var()->get_position()-1].second; // substitution cost on record + } + if ((*e).get_const() != 0) + num_var++; + if (num_var > 1) + cost += num_var - 1; // addition cost + + if (cost < min_cost) { + min_cost = cost; + eq = *e; + } + } + + if (min_cost < INT_MAX) + return std::make_pair(eq, min_cost); + + for (EQ_Iterator e(c->EQs()); e; e++) + if ((*e).has_wildcards() && (*e).get_coef(v) != 0) { + bool is_assignment = true; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) { + std::pair result = find_floor_definition(R, v); + if (!result.first) { + is_assignment = false; + break; + } + } + if (!is_assignment) + continue; + + int cost = 0; + + if (abs((*e).get_coef(v)) != 1) + cost += 4; // divide cost + + int num_var = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if (cvi.curr_var() != v) { + num_var++; + if (abs(cvi.curr_coef()) != 1) + cost += 2; // multiply cost + if (cvi.curr_var()->kind() == Wildcard_Var) + cost += 10; // floor operation cost + else if (cvi.curr_var()->kind() == Global_Var && cvi.curr_var()->get_global_var()->arity() > 0) + cost += 20; // function cost + else if (cvi.curr_var()->kind() == Input_Var && + assigned_on_the_fly.size() >= cvi.curr_var()->get_position() && + assigned_on_the_fly[cvi.curr_var()->get_position()-1].first != NULL) + cost += assigned_on_the_fly[cvi.curr_var()->get_position()-1].second; // substitution cost on record + } + if ((*e).get_const() != 0) + num_var++; + if (num_var > 1) + cost += num_var - 1; // addition cost + + if (cost < min_cost) { + min_cost = cost; + eq = *e; + } + } + + return std::make_pair(eq, min_cost); +} + + +// +// find floor definition for variable v, e.g. m-c <= 4v <= m, (c is +// constant and 0 <= c < 4). this translates to v = floor(m, 4) and +// return 4v<=m in this case. All wildcards in such inequality are +// also floor defined. +// +std::pair find_floor_definition(const Relation &R, Variable_ID v, std::set excluded_floor_vars) { + Conjunct *c = const_cast(R).single_conjunct(); + + excluded_floor_vars.insert(v); + for (GEQ_Iterator e = c->GEQs(); e; e++) { + coef_t a = (*e).get_coef(v); + if (a >= -1) + continue; + a = -a; + + bool interested = true; + for (std::set::const_iterator i = excluded_floor_vars.begin(); i != excluded_floor_vars.end(); i++) + if ((*i) != v && (*e).get_coef(*i) != 0) { + interested = false; + break; + } + if (!interested) + continue; + + // check if any wildcard is floor defined + bool has_undefined_wc = false; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) + if (excluded_floor_vars.find(cvi.curr_var()) == excluded_floor_vars.end()) { + std::pair result = find_floor_definition(R, cvi.curr_var(), excluded_floor_vars); + if (!result.first) { + has_undefined_wc = true; + break; + } + } + if (has_undefined_wc) + continue; + + // find the matching upper bound for floor definition + for (GEQ_Iterator e2 = c->GEQs(); e2; e2++) + if ((*e2).get_coef(v) == a && (*e).get_const() + (*e2).get_const() < a) { + bool match = true; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + if ((*e2).get_coef(cvi.curr_var()) != -cvi.curr_coef()) { + match = false; + break; + } + if (!match) + continue; + for (Constr_Vars_Iter cvi(*e2); cvi; cvi++) + if ((*e).get_coef(cvi.curr_var()) != -cvi.curr_coef()) { + match = false; + break; + } + if (match) + return std::make_pair(true, *e); + } + } + + return std::make_pair(false, GEQ_Handle()); +} + +// +// find the stride involving the specified variable, the stride +// equality can have other wildcards as long as they are defined as +// floor variables. +// +std::pair find_simplest_stride(const Relation &R, Variable_ID v) { + int best_num_var = INT_MAX; + coef_t best_coef; + EQ_Handle best_eq; + Variable_ID best_stride_wc; + for (EQ_Iterator e(const_cast(R).single_conjunct()->EQs()); e; e++) + if ((*e).has_wildcards() && (*e).get_coef(v) != 0) { + bool is_stride = true; + bool found_free = false; + int num_var = 0; + int num_floor = 0; + Variable_ID stride_wc; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: { + bool is_free = true; + for (GEQ_Iterator e2(const_cast(R).single_conjunct()->GEQs()); e2; e2++) + if ((*e2).get_coef(cvi.curr_var()) != 0) { + is_free = false; + break; + } + if (is_free) { + if (found_free) + is_stride = false; + else { + found_free = true; + stride_wc = cvi.curr_var(); + } + } + else { + std::pair result = find_floor_definition(R, cvi.curr_var()); + if (result.first) + num_floor++; + else + is_stride = false; + } + break; + } + case Input_Var: + num_var++; + break; + default: + ; + } + + if (!is_stride) + break; + } + + if (is_stride) { + coef_t coef = abs((*e).get_coef(v)); + if (best_num_var == INT_MAX || coef < best_coef || + (coef == best_coef && num_var < best_num_var)) { + best_coef = coef; + best_num_var = num_var; + best_eq = *e; + best_stride_wc = stride_wc; + } + } + } + + if (best_num_var != INT_MAX) + return std::make_pair(best_eq, best_stride_wc); + else + return std::make_pair(EQ_Handle(), static_cast(NULL)); +} + +// +// convert relation to if-condition +// +CG_outputRepr *output_guard(CG_outputBuilder *ocg, const Relation &R, const std::vector > &assigned_on_the_fly) { + assert(R.n_out()==0); + + CG_outputRepr *result = NULL; + Conjunct *c = const_cast(R).single_conjunct(); + + // e.g. 4i=5*j + for (EQ_Iterator e = c->EQs(); e; e++) + if (!(*e).has_wildcards()) { + CG_outputRepr *lhs = NULL; + CG_outputRepr *rhs = NULL; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + rhs = ocg->CreatePlus(rhs, v); + else + rhs = ocg->CreatePlus(rhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + coef_t c = (*e).get_const(); + + CG_outputRepr *term; + if (lhs == NULL) + term = ocg->CreateEQ(rhs, ocg->CreateInt(c)); + else { + if (c > 0) + rhs = ocg->CreateMinus(rhs, ocg->CreateInt(c)); + else if (c < 0) + rhs = ocg->CreatePlus(rhs, ocg->CreateInt(-c)); + else if (rhs == NULL) + rhs = ocg->CreateInt(0); + term = ocg->CreateEQ(lhs, rhs); + } + result = ocg->CreateAnd(result, term); + } + + // e.g. i>5j + for (GEQ_Iterator e = c->GEQs(); e; e++) + if (!(*e).has_wildcards()) { + CG_outputRepr *lhs = NULL; + CG_outputRepr *rhs = NULL; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + rhs = ocg->CreatePlus(rhs, v); + else + rhs = ocg->CreatePlus(rhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + coef_t c = (*e).get_const(); + + CG_outputRepr *term; + if (lhs == NULL) + term = ocg->CreateLE(rhs, ocg->CreateInt(c)); + else { + if (c > 0) + rhs = ocg->CreateMinus(rhs, ocg->CreateInt(c)); + else if (c < 0) + rhs = ocg->CreatePlus(rhs, ocg->CreateInt(-c)); + else if (rhs == NULL) + rhs = ocg->CreateInt(0); + term = ocg->CreateGE(lhs, rhs); + } + result = ocg->CreateAnd(result, term); + } + + // e.g. 4i=5j+4alpha + for (EQ_Iterator e = c->EQs(); e; e++) + if ((*e).has_wildcards()) { + Variable_ID wc; + int num_wildcard = 0; + int num_positive = 0; + int num_negative = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + if (cvi.curr_var()->kind() == Wildcard_Var) { + num_wildcard++; + wc = cvi.curr_var(); + } + else { + if (cvi.curr_coef() > 0) + num_positive++; + else + num_negative++; + } + } + + if (num_wildcard > 1) { + delete result; + throw codegen_error("Can't generate equality condition with multiple wildcards"); + } + int sign = (num_positive>=num_negative)?1:-1; + + CG_outputRepr *lhs = NULL; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + if (cvi.curr_var() != wc) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (sign == 1) { + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + lhs = ocg->CreateMinus(lhs, v); + else + lhs = ocg->CreateMinus(lhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + else { + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreateMinus(lhs, v); + else + lhs = ocg->CreateMinus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + } + } + coef_t c = (*e).get_const(); + if (sign == 1) { + if (c > 0) + lhs = ocg->CreatePlus(lhs, ocg->CreateInt(c)); + else if (c < 0) + lhs = ocg->CreateMinus(lhs, ocg->CreateInt(-c)); + } + else { + if (c > 0) + lhs = ocg->CreateMinus(lhs, ocg->CreateInt(c)); + else if (c < 0) + lhs = ocg->CreatePlus(lhs, ocg->CreateInt(-c)); + } + + lhs = ocg->CreateIntegerMod(lhs, ocg->CreateInt(abs((*e).get_coef(wc)))); + CG_outputRepr *term = ocg->CreateEQ(lhs, ocg->CreateInt(0)); + result = ocg->CreateAnd(result, term); + } + + // e.g. 4alpha<=i<=5alpha + for (GEQ_Iterator e = c->GEQs(); e; e++) + if ((*e).has_wildcards()) { + Variable_ID wc; + int num_wildcard = 0; + for (Constr_Vars_Iter cvi(*e, true); cvi; cvi++) + if (num_wildcard == 0) { + wc = cvi.curr_var(); + num_wildcard = 1; + } + else + num_wildcard++; + + if (num_wildcard > 1) { + delete result; + // e.g. c*alpha - x >= 0 (*) + // -d*alpha + y >= 0 (*) + // e1*alpha + f1*beta + g1 >= 0 (**) + // e2*alpha + f2*beta + g2 >= 0 (**) + // ... + // TODO: should generate a testing loop for alpha using its lower and + // upper bounds from (*) constraints and do the same if-condition test + // for beta from each pair of opposite (**) constraints as above, + // and exit the loop when if-condition satisfied. + throw codegen_error("Can't generate multiple wildcard GEQ guards right now"); + } + + coef_t c = (*e).get_coef(wc); + int sign = (c>0)?1:-1; + + GEQ_Iterator e2 = e; + e2++; + for ( ; e2; e2++) { + coef_t c2 = (*e2).get_coef(wc); + if (c2 == 0) + continue; + int sign2 = (c2>0)?1:-1; + if (sign != -sign2) + continue; + int num_wildcard2 = 0; + for (Constr_Vars_Iter cvi(*e2, true); cvi; cvi++) + num_wildcard2++; + if (num_wildcard2 > 1) + continue; + + GEQ_Handle lb, ub; + if (sign == 1) { + lb = (*e); + ub = (*e2); + } + else { + lb = (*e2); + ub = (*e); + } + + CG_outputRepr *lhs = NULL; + for (Constr_Vars_Iter cvi(lb); cvi; cvi++) + if (cvi.curr_var() != wc) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + lhs = ocg->CreateMinus(lhs, v); + else + lhs = ocg->CreateMinus(lhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + lhs = ocg->CreatePlus(lhs, v); + else + lhs = ocg->CreatePlus(lhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + coef_t c = lb.get_const(); + if (c > 0) + lhs = ocg->CreateMinus(lhs, ocg->CreateInt(c)); + else if (c < 0) + lhs = ocg->CreatePlus(lhs, ocg->CreateInt(-c)); + + CG_outputRepr *rhs = NULL; + for (Constr_Vars_Iter cvi(ub); cvi; cvi++) + if (cvi.curr_var() != wc) { + CG_outputRepr *v = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + coef_t coef = cvi.curr_coef(); + if (coef > 0) { + if (coef == 1) + rhs = ocg->CreatePlus(rhs, v); + else + rhs = ocg->CreatePlus(rhs, ocg->CreateTimes(ocg->CreateInt(coef), v)); + } + else { // coef < 0 + if (coef == -1) + rhs = ocg->CreateMinus(rhs, v); + else + rhs = ocg->CreateMinus(rhs, ocg->CreateTimes(ocg->CreateInt(-coef), v)); + } + } + c = ub.get_const(); + if (c > 0) + rhs = ocg->CreatePlus(rhs, ocg->CreateInt(c)); + else if (c < 0) + rhs = ocg->CreateMinus(rhs, ocg->CreateInt(-c)); + + rhs = ocg->CreateIntegerFloor(rhs, ocg->CreateInt(-ub.get_coef(wc))); + rhs = ocg->CreateTimes(ocg->CreateInt(lb.get_coef(wc)), rhs); + CG_outputRepr *term = ocg->CreateLE(lhs, rhs); + result = ocg->CreateAnd(result, term); + } + } + + return result; +} + + +// +// return NULL if 0 +// +CG_outputRepr *output_inequality_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const Relation &R, const std::vector > &assigned_on_the_fly, std::set excluded_floor_vars) { + const_cast(R).setup_names(); // hack + + coef_t a = inequality.get_coef(v); + assert(a != 0); + excluded_floor_vars.insert(v); + + CG_outputRepr *repr = NULL; + for (Constr_Vars_Iter cvi(inequality); cvi; cvi++) + if (cvi.curr_var() != v) { + CG_outputRepr *t; + if (cvi.curr_var()->kind() == Wildcard_Var) { + std::pair result = find_floor_definition(R, cvi.curr_var(), excluded_floor_vars); + if (!result.first) { + delete repr; + throw codegen_error("Can't generate bound expression with wildcard not involved in floor definition"); + } + try { + t = output_inequality_repr(ocg, result.second, cvi.curr_var(), R, assigned_on_the_fly, excluded_floor_vars); + } + catch (const std::exception &e) { + delete repr; + throw e; + } + } + else + t = output_ident(ocg, R, cvi.curr_var(), assigned_on_the_fly); + + coef_t coef = cvi.curr_coef(); + if (a > 0) { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { + if (coef == -1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + else { + if (coef > 0) { + if (coef == 1) + repr = ocg->CreatePlus(repr, t); + else + repr = ocg->CreatePlus(repr, ocg->CreateTimes(ocg->CreateInt(coef), t)); + } + else { + if (coef == -1) + repr = ocg->CreateMinus(repr, t); + else + repr = ocg->CreateMinus(repr, ocg->CreateTimes(ocg->CreateInt(-coef), t)); + } + } + } + coef_t c = inequality.get_const(); + if (c > 0) { + if (a > 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(c)); + else + repr = ocg->CreatePlus(repr, ocg->CreateInt(c)); + } + else if (c < 0) { + if (a > 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(-c)); + else + repr = ocg->CreateMinus(repr, ocg->CreateInt(-c)); + } + + if (abs(a) == 1) + return repr; + else if (a > 0) + return ocg->CreateIntegerCeil(repr, ocg->CreateInt(a)); + else // a < 0 + return ocg->CreateIntegerFloor(repr, ocg->CreateInt(-a)); +} + + +// +// nothing special, just an alias +// +CG_outputRepr *output_upper_bound_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const Relation &R, const std::vector > &assigned_on_the_fly) { + assert(inequality.get_coef(v) < 0); + CG_outputRepr* zero_; + + zero_ = output_inequality_repr(ocg, inequality, v, R, assigned_on_the_fly); + + if(!zero_) + zero_ = ocg->CreateInt(0); + + return zero_; + +} + + +// +// output lower bound with respect to lattice +// +CG_outputRepr *output_lower_bound_repr(CG_outputBuilder *ocg, const GEQ_Handle &inequality, Variable_ID v, const EQ_Handle &stride_eq, Variable_ID wc, const Relation &R, const Relation &known, const std::vector > &assigned_on_the_fly) { + assert(inequality.get_coef(v) > 0); + CG_outputRepr* zero_; + if (wc == NULL || bound_must_hit_stride(inequality, v, stride_eq, wc, R, known)){ + zero_ = output_inequality_repr(ocg, inequality, v, R, assigned_on_the_fly); + if(!zero_) + zero_ = ocg->CreateInt(0); + + return zero_; + } + CG_outputRepr *strideBoundRepr = NULL; + int sign = (stride_eq.get_coef(v)>0)?1:-1; + for (Constr_Vars_Iter cvi(stride_eq); cvi; cvi++) { + Variable_ID v2 = cvi.curr_var(); + if (v2 == v || v2 == wc) + continue; + + CG_outputRepr *v_repr; + if (v2->kind() == Input_Var || v2->kind() == Global_Var) + v_repr = output_ident(ocg, R, v2, assigned_on_the_fly); + else if (v2->kind() == Wildcard_Var) { + std::pair result = find_floor_definition(R, v2); + assert(result.first); + v_repr = output_inequality_repr(ocg, result.second, v2, R, assigned_on_the_fly); + } + + coef_t coef = cvi.curr_coef(); + if (sign < 0) { + if (coef > 0) { + if (coef == 1) + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(coef), v_repr)); + } + else { // coef < 0 + if (coef == -1) + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(-coef), v_repr)); + } + } + else { + if (coef > 0) { + if (coef == 1) + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(coef), v_repr)); + } + else { // coef < 0 + if (coef == -1) + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, v_repr); + else + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateTimes(ocg->CreateInt(-coef), v_repr)); + } + } + } + coef_t c = stride_eq.get_const(); + if (c > 0) { + if (sign < 0) + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateInt(c)); + else + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateInt(c)); + } + else if (c < 0) { + if (sign < 0) + strideBoundRepr = ocg->CreateMinus(strideBoundRepr, ocg->CreateInt(-c)); + else + strideBoundRepr = ocg->CreatePlus(strideBoundRepr, ocg->CreateInt(-c)); + } + + CG_outputRepr *repr = output_inequality_repr(ocg, inequality, v, R, assigned_on_the_fly); + CG_outputRepr *repr2 = ocg->CreateCopy(repr); + repr = ocg->CreatePlus(repr2, ocg->CreateIntegerMod(ocg->CreateMinus(strideBoundRepr, repr), ocg->CreateInt(abs(stride_eq.get_coef(wc))))); + + return repr; +} + + +// +// return loop control structure only +// +CG_outputRepr *output_loop(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector > &assigned_on_the_fly) { + std::pair result = find_simplest_stride(R, const_cast(R).set_var(level)); + if (result.second != NULL) + assert(abs(result.first.get_coef(const_cast(R).set_var(level))) == 1); + + std::vector lbList, ubList; + try { + + coef_t const_lb = negInfinity, const_ub = posInfinity; + + for (GEQ_Iterator e(const_cast(R).single_conjunct()->GEQs()); e; e++) { + coef_t coef = (*e).get_coef(const_cast(R).set_var(level)); + + if (coef > 0) { + CG_outputRepr *repr = output_lower_bound_repr(ocg, *e, const_cast(R).set_var(level), result.first, result.second, R, known, assigned_on_the_fly); + if (repr == NULL) + repr = ocg->CreateInt(0); + lbList.push_back(repr); + + if ((*e).is_const(const_cast(R).set_var(level))){ + if(!result.second) { + + //no variables but v in constr + coef_t L,m; + L = -((*e).get_const()); + + m = (*e).get_coef(const_cast(R).set_var(level)); + coef_t sb = (int) (ceil(((float) L) /m)); + set_max(const_lb, sb); + } + else{ + + coef_t L,m,s,c; + L = -((*e).get_const()); + m = (*e).get_coef(const_cast(R).set_var(level)); + s = abs(result.first.get_coef(result.second)); + c = result.first.get_const(); + coef_t sb = (s * (int) (ceil( (float) (L - (c * m)) /(s*m))))+ c; + set_max(const_lb, sb); + + } + } + + } + else if (coef < 0) { + CG_outputRepr *repr = output_upper_bound_repr(ocg, *e, const_cast(R).set_var(level), R, assigned_on_the_fly); + if (repr == NULL) + repr = ocg->CreateInt(0); + ubList.push_back(repr); + + if ((*e).is_const(const_cast(R).set_var(level))) { + // no variables but v in constraint + set_min(const_ub,-(*e).get_const()/(*e).get_coef(const_cast(R).set_var(level))); + } + + } + } + + if(fillInBounds && lbList.size() == 1 && const_lb != negInfinity) + lowerBoundForLevel = const_lb; + + if(fillInBounds && const_ub != posInfinity) + upperBoundForLevel = const_ub; + if (lbList.size() == 0) + throw codegen_error("missing lower bound at loop level " + to_string(level)); + if (ubList.size() == 0) + throw codegen_error("missing upper bound at loop level " + to_string(level)); + } + catch (const std::exception &e) { + for (int i = 0; i < lbList.size(); i++) + delete lbList[i]; + for (int i = 0; i < ubList.size(); i++) + delete ubList[i]; + throw e; + } + + CG_outputRepr *lbRepr = NULL; + if (lbList.size() > 1) + lbRepr = ocg->CreateInvoke("max", lbList); + else // (lbList.size() == 1) + lbRepr = lbList[0]; + + CG_outputRepr *ubRepr = NULL; + if (ubList.size() > 1) + ubRepr = ocg->CreateInvoke("min", ubList); + else // (ubList.size() == 1) + ubRepr = ubList[0]; + + CG_outputRepr *stRepr; + if (result.second == NULL) + stRepr = ocg->CreateInt(1); + else + stRepr = ocg->CreateInt(abs(result.first.get_coef(result.second))); + CG_outputRepr *indexRepr = output_ident(ocg, R, const_cast(R).set_var(level), assigned_on_the_fly); + return ocg->CreateInductive(indexRepr, lbRepr, ubRepr, stRepr); +} + + +// +// parameter f_root is inside f_exists, not the other way around. +// return replicated variable in new relation, with all cascaded floor definitions +// using wildcards defined in the same way as in the original relation. +// +Variable_ID replicate_floor_definition(const Relation &R, const Variable_ID floor_var, + Relation &r, F_Exists *f_exists, F_And *f_root, + std::map &exists_mapping) { + assert(R.n_out() == 0 && r.n_out() == 0 && R.n_inp() == r.n_inp()); + + std::set excluded_floor_vars; + std::stack to_fill; + to_fill.push(floor_var); + + while (!to_fill.empty()) { + Variable_ID v = to_fill.top(); + to_fill.pop(); + if (excluded_floor_vars.find(v) != excluded_floor_vars.end()) + continue; + + std::pair result = find_floor_definition(R, v, excluded_floor_vars); + assert(result.first); + excluded_floor_vars.insert(v); + + GEQ_Handle h1 = f_root->add_GEQ(); + GEQ_Handle h2 = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(result.second); cvi; cvi++) { + Variable_ID v2 = cvi.curr_var(); + switch (v2->kind()) { + case Input_Var: { + int pos = v2->get_position(); + h1.update_coef(r.input_var(pos), cvi.curr_coef()); + h2.update_coef(r.input_var(pos), -cvi.curr_coef()); + break; + } + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find(v2); + Variable_ID v3; + if (p == exists_mapping.end()) { + v3 = f_exists->declare(); + exists_mapping[v2] = v3; + } + else + v3 = p->second; + h1.update_coef(v3, cvi.curr_coef()); + h2.update_coef(v3, -cvi.curr_coef()); + if (v2 != v) + to_fill.push(v2); + break; + } + case Global_Var: { + Global_Var_ID g = v2->get_global_var(); + Variable_ID v3; + if (g->arity() == 0) + v3 = r.get_local(g); + else + v3 = r.get_local(g, v2->function_of()); + h1.update_coef(v3, cvi.curr_coef()); + h2.update_coef(v3, -cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h1.update_const(result.second.get_const()); + h2.update_const(-result.second.get_const()-result.second.get_coef(v)-1); + } + + if (floor_var->kind() == Input_Var) + return r.input_var(floor_var->get_position()); + else if (floor_var->kind() == Wildcard_Var) + return exists_mapping[floor_var]; + else + assert(false); +} + + +// +// pick one guard condition from relation. it can involve multiple +// constraints when involving wildcards, as long as its complement +// is a single conjunct. +// +Relation pick_one_guard(const Relation &R, int level) { + assert(R.n_out()==0); + + Relation r = Relation::True(R.n_set()); + + for (GEQ_Iterator e(const_cast(R).single_conjunct()->GEQs()); e; e++) + if (!(*e).has_wildcards()) { + r.and_with_GEQ(*e); + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + + for (EQ_Iterator e(const_cast(R).single_conjunct()->EQs()); e; e++) + if (!(*e).has_wildcards()) { + r.and_with_GEQ(*e); + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + + for (EQ_Iterator e(const_cast(R).single_conjunct()->EQs()); e; e++) + if ((*e).has_wildcards()) { + int num_wildcard = 0; + int max_level = 0; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + num_wildcard++; + break; + case Input_Var: + if (cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + break; + default: + ; + } + + if (num_wildcard == 1 && max_level != level-1) { + r.and_with_EQ(*e); + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + } + + for (GEQ_Iterator e(const_cast(R).single_conjunct()->GEQs()); e; e++) + if ((*e).has_wildcards()) { + int num_wildcard = 0; + int max_level = 0; + bool direction; + Variable_ID wc; + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + num_wildcard++; + wc = cvi.curr_var(); + direction = cvi.curr_coef()>0?true:false; + break; + case Input_Var: + if (cvi.curr_var()->get_position() > max_level) + max_level = cvi.curr_var()->get_position(); + break; + default: + ; + } + + if (num_wildcard == 1 && max_level != level-1) { + // find the pairing inequality + GEQ_Iterator e2 = e; + e2++; + for ( ; e2; e2++) { + int num_wildcard2 = 0; + int max_level2 = 0; + bool direction2; + Variable_ID wc2; + for (Constr_Vars_Iter cvi(*e2); cvi; cvi++) + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + num_wildcard2++; + wc2 = cvi.curr_var(); + direction2 = cvi.curr_coef()>0?true:false; + break; + case Input_Var: + if (cvi.curr_var()->get_position() > max_level2) + max_level2 = cvi.curr_var()->get_position(); + break; + default: + ; + } + + if (num_wildcard2 == 1 && max_level2 != level-1 && wc2 == wc && direction2 == not direction) { + F_Exists *f_exists = r.and_with_and()->add_exists(); + Variable_ID wc3 = f_exists->declare(); + F_And *f_root = f_exists->add_and(); + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e); cvi; cvi++) { + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + h.update_coef(wc3, cvi.curr_coef()); + break; + case Input_Var: + h.update_coef(r.input_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r.get_local(g); + else + v = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e).get_const()); + + h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*e2); cvi; cvi++) { + switch (cvi.curr_var()->kind()) { + case Wildcard_Var: + h.update_coef(wc3, cvi.curr_coef()); + break; + case Input_Var: + h.update_coef(r.input_var(cvi.curr_var()->get_position()), cvi.curr_coef()); + break; + case Global_Var: { + Global_Var_ID g = cvi.curr_var()->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r.get_local(g); + else + v = r.get_local(g, cvi.curr_var()->function_of()); + h.update_coef(v, cvi.curr_coef()); + break; + } + default: + assert(false); + } + } + h.update_const((*e2).get_const()); + + r.simplify(); + r.copy_names(R); + r.setup_names(); + return r; + } + } + } + } +} + + +// +// heavy lifting for code output for one leaf node +// +CG_outputRepr *leaf_print_repr(BoolSet<> active, const std::map &guards, + CG_outputRepr *guard_repr, const Relation &known, + int indent, CG_outputBuilder *ocg, const std::vector &remap, + const std::vector &xforms, const std::vector &stmts, + const std::vector > &assigned_on_the_fly) { + if (active.num_elem() == 0) + return NULL; + + CG_outputRepr *stmt_list = NULL; + for (BoolSet<>::iterator i = active.begin(); i != active.end(); i++) { + std::map::const_iterator j = guards.find(*i); + if (j == guards.end() || Must_Be_Subset(copy(known), copy(j->second))) { + Relation mapping = Inverse(copy((xforms[remap[*i]]))); + mapping.simplify(); + mapping.setup_names(); + std::vector loop_vars; + for (int k = 1; k <= mapping.n_out(); k++) { + loop_vars.push_back(mapping.output_var(k)->name()); +// std::cout << "CG_Utils:: " << k << ", " << mapping.output_var(k)->name().c_str() << "\n"; + } + std::vector sList = output_substitutions(ocg, mapping, assigned_on_the_fly); + stmt_list = ocg->StmtListAppend(stmt_list, ocg->CreateSubstitutedStmt((guard_repr==NULL)?indent:indent+1, stmts[remap[*i]]->clone(), loop_vars, sList)); + active.unset(*i); + } + } + + if (stmt_list != NULL) { + if (active.num_elem() != 0) + stmt_list = ocg->StmtListAppend(stmt_list, leaf_print_repr(active, guards, NULL, known, (guard_repr==NULL)?indent:indent+1, ocg, remap, xforms, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + else { + Relation then_cond = find_best_guard(const_cast &>(guards)[*(active.begin())], active, guards); + assert(!then_cond.is_obvious_tautology()); + Relation new_then_known = Intersection(copy(known), copy(then_cond)); + new_then_known.simplify(); + Relation else_cond = Complement(copy(then_cond)); + else_cond.simplify(); + Relation new_else_known = Intersection(copy(known), copy(else_cond)); + new_else_known.simplify(); + + BoolSet<> then_active(active.size()), else_active(active.size()), indep_active(active.size()); + std::map then_guards, else_guards; + for (BoolSet<>::iterator i = active.begin(); i != active.end(); i++) { + Relation &r = const_cast &>(guards)[*i]; + if (Must_Be_Subset(copy(r), copy(then_cond))) { + Relation r2 = Gist(copy(r), copy(then_cond), 1); + if (!r2.is_obvious_tautology()) + then_guards[*i] = r2; + then_active.set(*i); + } + else if (Must_Be_Subset(copy(r), copy(else_cond))) { + Relation r2 = Gist(copy(r), copy(else_cond), 1); + if (!r2.is_obvious_tautology()) + else_guards[*i] = r2; + else_active.set(*i); + } + else + indep_active.set(*i); + } + assert(!then_active.empty()); + + CG_outputRepr *new_guard_repr = output_guard(ocg, then_cond, assigned_on_the_fly); + if (else_active.empty() && indep_active.empty()) { + guard_repr = ocg->CreateAnd(guard_repr, new_guard_repr); + return leaf_print_repr(then_active, then_guards, guard_repr, new_then_known, indent, ocg, remap, xforms, stmts, assigned_on_the_fly); + } + else if (else_active.empty() && !indep_active.empty()) { + int new_indent = (guard_repr==NULL)?indent:indent+1; + stmt_list = leaf_print_repr(then_active, then_guards, new_guard_repr, new_then_known, new_indent, ocg, remap, xforms, stmts, assigned_on_the_fly); + stmt_list = ocg->StmtListAppend(stmt_list, leaf_print_repr(indep_active, guards, NULL, known, new_indent, ocg, remap, xforms, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + else { // (!else_active.empty()) + int new_indent = (guard_repr==NULL)?indent:indent+1; + CG_outputRepr *then_stmt_list = leaf_print_repr(then_active, then_guards, NULL, new_then_known, new_indent+1, ocg, remap, xforms, stmts, assigned_on_the_fly); + CG_outputRepr *else_stmt_list = leaf_print_repr(else_active, else_guards, NULL, new_else_known, new_indent+1, ocg, remap, xforms, stmts, assigned_on_the_fly); + stmt_list = ocg->CreateIf(new_indent, new_guard_repr, then_stmt_list, else_stmt_list); + if (!indep_active.empty()) + stmt_list = ocg->StmtListAppend(stmt_list, leaf_print_repr(indep_active, guards, NULL, known, new_indent, ocg, remap, xforms, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + } +} + + +// +// heavy lifting for code output for one level of loop nodes +// +CG_outputRepr *loop_print_repr(const std::vector &loops, int start, int end, + const Relation &guard, CG_outputRepr *guard_repr, + int indent, CG_outputBuilder *ocg, const std::vector &stmts, + const std::vector > &assigned_on_the_fly) { + if (start >= end) + return NULL; + + Relation R = Gist(copy(loops[start]->guard_), copy(guard), 1); + if (Must_Be_Subset(Intersection(copy(loops[start]->known_), copy(guard)), copy(R))) { + int new_indent = (guard_repr==NULL)?indent:indent+1; + int i = start+1; + for ( ; i < end; i++) + if (!Gist(copy(loops[i]->guard_), copy(guard), 1).is_obvious_tautology()) + break; + CG_outputRepr *stmt_list = NULL; + for (int j = start; j < i; j++) + stmt_list = ocg->StmtListAppend(stmt_list, loops[j]->printRepr(false, new_indent, ocg, stmts, assigned_on_the_fly)); + stmt_list = ocg->StmtListAppend(stmt_list, loop_print_repr(loops, i, end, guard, NULL, new_indent, ocg, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + + Relation then_cond = find_best_guard(R, loops, start, end); + assert(!then_cond.is_obvious_tautology()); + Relation else_cond = Complement(copy(then_cond)); + else_cond.simplify(); + + std::vector then_loops, else_loops, indep_loops; + int i = start; + for ( ; i < end; i++) + if (!Must_Be_Subset(copy(loops[i]->guard_), copy(then_cond))) + break; + int j = i; + for ( ; j < end; j++) + if (!Must_Be_Subset(copy(loops[j]->guard_), copy(else_cond))) + break; + assert(i>start); + + CG_outputRepr *new_guard_repr = output_guard(ocg, then_cond, assigned_on_the_fly); + if (j == i && end == j) { + guard_repr = ocg->CreateAnd(guard_repr, new_guard_repr); + Relation new_guard = Intersection(copy(guard), copy(then_cond)); + new_guard.simplify(); + return loop_print_repr(loops, start, end, new_guard, guard_repr, indent, ocg, stmts, assigned_on_the_fly); + } + else if (j == i && end > j) { + int new_indent = (guard_repr==NULL)?indent:indent+1; + Relation new_guard = Intersection(copy(guard), copy(then_cond)); + new_guard.simplify(); + CG_outputRepr *stmt_list = loop_print_repr(loops, start, i, new_guard, new_guard_repr, new_indent, ocg, stmts, assigned_on_the_fly); + stmt_list = ocg->StmtListAppend(stmt_list, loop_print_repr(loops, j, end, guard, NULL, new_indent, ocg, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } + else { // (j > i) + int new_indent = (guard_repr==NULL)?indent:indent+1; + Relation then_new_guard = Intersection(copy(guard), copy(then_cond)); + then_new_guard.simplify(); + CG_outputRepr *then_stmt_list = loop_print_repr(loops, start, i, then_new_guard, NULL, new_indent+1, ocg, stmts, assigned_on_the_fly); + Relation else_new_guard = Intersection(copy(guard), copy(else_cond)); + else_new_guard.simplify(); + CG_outputRepr *else_stmt_list = loop_print_repr(loops, i, j, else_new_guard, NULL, new_indent+1, ocg, stmts, assigned_on_the_fly); + CG_outputRepr *stmt_list = ocg->CreateIf(new_indent, new_guard_repr, then_stmt_list, else_stmt_list); + stmt_list = ocg->StmtListAppend(stmt_list, loop_print_repr(loops, j, end, guard, NULL, new_indent, ocg, stmts, assigned_on_the_fly)); + if (guard_repr == NULL) + return stmt_list; + else + return ocg->CreateIf(indent, guard_repr, stmt_list, NULL); + } +} + +} diff --git a/omega/code_gen/src/code_gen.cc b/omega/code_gen/src/code_gen.cc new file mode 100644 index 0000000..168c86b --- /dev/null +++ b/omega/code_gen/src/code_gen.cc @@ -0,0 +1,656 @@ +/***************************************************************************** + Copyright (C) 1994-2000 University of Maryland + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + Start code generation process here. + + Notes: + + History: + 04/24/96 MMGenerateCode implementation, added by D people. Lei Zhou +*****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace omega { + + +int last_level;// Should not be global, but it is. +SetTuple new_IS; +SetTupleTuple projected_nIS; +Tuple statementInfo; +RelTuple transformations; + +//protonu--adding stuff to make Chun's code work with Gabe's +Tuple< Tuple > smtNonSplitLevels; +Tuple< Tuple > loopIdxNames;//per stmt +std::vector< std::pair > syncs; + +//protonu-putting this in for now, not sure what all these do +//This lovely ugly hack allows us to extract hard upper-bounds at +//specific loop levels +int checkLoopLevel; +int stmtForLoopCheck; +int upperBoundForLevel; +int lowerBoundForLevel; +bool fillInBounds; + +//trick to static init checkLoopLevel to 0 +class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} }; +static JunkStaticInit junkInitInstance__; + +//end--protonu. + + +CG_result * gen_recursive(int level, IntTuple &isActive); + + +int code_gen_debug=0; + + +SetTuple filter_function_symbols(SetTuple &sets, bool keep_fs){ + SetTuple new_sets(sets.size()); + for(int i = 1; i <= sets.size(); i++) { + Relation R = sets[i]; + Relation &S = new_sets[i]; + assert(R.is_set()); + + S = Relation(R.n_set()); + S.copy_names(R); + F_Exists *fe = S.add_exists(); + F_Or *fo = fe->add_or(); + for(DNF_Iterator D(R.query_DNF()); D; D++) { + F_And *fa = fo->add_and(); + Variable_ID_Tuple &oldlocals = (*D)->locals(); + Section newlocals = fe->declare_tuple(oldlocals.size()); + + /* copy constraints. This is much more difficult than it needs + to be, but add_EQ(Constraint_Handle) doesn't work because it can't + keep track of existentially quantified varaibles across calls. + Sigh. */ + + for(EQ_Iterator e(*D); e; e++) + if((max_fs_arity(*e) > 0) == keep_fs){ + EQ_Handle n = fa->add_EQ(); + for(Constr_Vars_Iter cvi(*e,false);cvi;cvi++) + if((*cvi).var->kind() == Wildcard_Var) + n.update_coef(newlocals[oldlocals.index((*cvi).var)], + (*cvi).coef); + else + if((*cvi).var->kind() == Global_Var) + n.update_coef(S.get_local((*cvi).var->get_global_var(), + (*cvi).var->function_of()), + (*cvi).coef); + else + n.update_coef((*cvi).var,(*cvi).coef); + n.update_const((*e).get_const()); + n.finalize(); + } + + for(GEQ_Iterator g(*D); g; g++) + if((max_fs_arity(*g) > 0) == keep_fs) { + GEQ_Handle n = fa->add_GEQ(); + for(Constr_Vars_Iter cvi(*g,false);cvi;cvi++) + if((*cvi).var->kind() == Wildcard_Var) + n.update_coef(newlocals[oldlocals.index((*cvi).var)], + (*cvi).coef); + else + if((*cvi).var->kind() == Global_Var) + n.update_coef(S.get_local((*cvi).var->get_global_var(), + (*cvi).var->function_of()), + (*cvi).coef); + else + n.update_coef((*cvi).var,(*cvi).coef); + n.update_const((*g).get_const()); + n.finalize(); + } + } + S.finalize(); + } + + return new_sets; +} + + +RelTuple strip_function_symbols(SetTuple &sets) { + return filter_function_symbols(sets,false); +} + +RelTuple extract_function_symbols(SetTuple &sets) { + return filter_function_symbols(sets,true); +} + + +std::string MMGenerateCode(RelTuple &T, SetTuple &old_IS, Relation &known, int effort) { + Tuple nameInfo; + for (int stmt = 1; stmt <= T.size(); stmt++) + nameInfo.append(new CG_stringRepr("s" + to_string(stmt))); + + CG_stringBuilder ocg; + CG_stringRepr *sRepr = static_cast(MMGenerateCode(&ocg, T, old_IS, nameInfo, known, effort)); + + for (int i = 1; i <= nameInfo.size(); i++) + delete nameInfo[i]; + if (sRepr != NULL) + return GetString(sRepr); + else + return std::string(); +} + + +//***************************************************************************** +// MMGenerateCode implementation, added by D people. Lei Zhou, Apr. 24, 96 +//***************************************************************************** +CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, const Tuple &stmt_content, Relation &known, int effort) { + int stmts = T.size(); + if (stmts == 0) + return ocg->CreateComment(1, "No statements found!"); + if (!known.is_null()) + known.simplify(); + + // prepare iteration spaces by splitting disjoint conjunctions + int maxStmt = 1; + last_level = 0; + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = T[stmt].n_out(); + if (old_dim > last_level) + last_level = old_dim; + + for (int i = 1; i <= old_IS[stmt].n_set(); i++) + T[stmt].name_input_var(i, old_IS[stmt].set_var(i)->name()); + for (int i = 1; i <= old_dim; i++) + T[stmt].name_output_var(i, std::string("t")+to_string(i)); + T[stmt].setup_names(); + + Relation R = Range(Restrict_Domain(copy(T[stmt]), copy(old_IS[stmt]))); + R.simplify(); + while(R.is_upper_bound_satisfiable()) { + new_IS.reallocate(maxStmt); + transformations.reallocate(maxStmt); + statementInfo.reallocate(maxStmt); + DNF *dnf = R.query_DNF(); + DNF_Iterator c(dnf); + Relation R2 = Relation(R, *c); + R2.simplify(); + if (R2.is_inexact()) + throw codegen_error("unknown constraint in loop bounds"); + if (known.is_null()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + else { + Relation R2_extended = copy(R2); + Relation known_extended = copy(known); + if (R2.n_set() > known.n_set()) + known_extended = Extend_Set(known_extended, R2.n_set()-known.n_set()); + else if (R2.n_set() < known.n_set()) + R2_extended = Extend_Set(R2_extended, known.n_set()-R2.n_set()); + if (Intersection(R2_extended, known_extended).is_upper_bound_satisfiable()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + } + c.next(); + if (!c.live()) + break; + if(code_gen_debug) { + fprintf(DebugFile, "splitting iteration space for disjoint form\n"); + fprintf(DebugFile, "Original iteration space: \n"); + R.print_with_subs(DebugFile); + fprintf(DebugFile, "First conjunct: \n"); + R2.print_with_subs(DebugFile); + } + Relation remainder(R, *c); + c.next(); + while (c.live()) { + remainder = Union(remainder, Relation(R, *c)); + c.next(); + } + R = Difference(remainder, copy(R2)); + R.simplify(); + if(code_gen_debug) { + fprintf(DebugFile, "Remaining iteration space: \n"); + R.print_with_subs(DebugFile); + } + } + } + + // reset number of statements + stmts = maxStmt-1; + if(stmts == 0) + return ocg->CreateComment(1, "No points in any of the iteration spaces!"); + + // entend iteration spaces to maximum dimension + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = new_IS[stmt].n_set(); + if (old_dim < last_level) { + new_IS[stmt] = Extend_Set(new_IS[stmt], last_level-old_dim); + F_And *f_root = new_IS[stmt].and_with_and(); + for (int i = old_dim+1; i <= last_level; i++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(new_IS[stmt].set_var(i), 1); + h.update_const(posInfinity); + } + } + } + + // standarize the known condition + if(known.is_null()) { + known = Relation::True(last_level); + } + known = Extend_Set(known, last_level-known.n_set()); + for (int i = 1; i <= last_level; i++) + known.name_set_var(i, std::string("t")+to_string(i)); + known.setup_names(); + + // prepare projected subspaces for each loop level + projected_nIS.clear(); + projected_nIS.reallocate(last_level); + for(int i = 1; i <= last_level; i++ ) { + projected_nIS[i].reallocate(stmts); + } + for (int stmt = 1; stmt <= stmts; stmt++) { + if (last_level > 0) + projected_nIS[last_level][stmt] = new_IS[stmt]; + for (int i = last_level-1; i >= 1; i--) { + projected_nIS[i][stmt] = Project(copy(projected_nIS[i+1][stmt]), i+1, Set_Var); + projected_nIS[i][stmt].simplify(); + } + } + + // recursively generate AST + IntTuple allStmts(stmts); + for(int i = 1; i <= stmts; i++) + allStmts[i] = 1; + CG_result *cg = gen_recursive(1, allStmts); + + // always force finite bounds + cg = cg->recompute(known, known); + cg = cg->force_finite_bounds(); + + // loop overhead removal based on actual nesting depth -- by chun 09/17/2008 + for (int i = 1; i <= min(effort, cg->depth()); i++) + cg = cg->liftOverhead(i); + + // merge adjacent if-conditions -- by chun 10/24/2006 + cg->hoistGuard(); + + // really print out the loop + //CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector(last_level, NULL)); + CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector(last_level)); + delete cg; + cg = NULL; + projected_nIS.clear(); + transformations.clear(); + new_IS.clear(); + + return sRepr; +} + +//protonu--overload the above MMGenerateCode to take into the CUDA-CHiLL +CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, + const Tuple &stmt_content, Relation &known, + Tuple< IntTuple >& smtNonSplitLevels_, + std::vector< std::pair > syncs_, + const Tuple< Tuple >& loopIdxNames_, + int effort) { + int stmts = T.size(); + if (stmts == 0) + return ocg->CreateComment(1, "No statements found!"); + if (!known.is_null()) + known.simplify(); + + //protonu-- + //easier to handle this as a global + smtNonSplitLevels = smtNonSplitLevels_; + syncs = syncs_; + loopIdxNames = loopIdxNames_; + //end-protonu + + + + // prepare iteration spaces by splitting disjoint conjunctions + int maxStmt = 1; + last_level = 0; + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = T[stmt].n_out(); + if (old_dim > last_level) + last_level = old_dim; + + for (int i = 1; i <= old_IS[stmt].n_set(); i++) + T[stmt].name_input_var(i, old_IS[stmt].set_var(i)->name()); + for (int i = 1; i <= old_dim; i++) + T[stmt].name_output_var(i, std::string("t")+to_string(i)); + T[stmt].setup_names(); + + Relation R = Range(Restrict_Domain(copy(T[stmt]), copy(old_IS[stmt]))); + R.simplify(); + while(R.is_upper_bound_satisfiable()) { + new_IS.reallocate(maxStmt); + transformations.reallocate(maxStmt); + statementInfo.reallocate(maxStmt); + + //protonu--putting in fix provided by Mark Hall + smtNonSplitLevels.reallocate(maxStmt); + //end-protonu + + + DNF *dnf = R.query_DNF(); + DNF_Iterator c(dnf); + Relation R2 = Relation(R, *c); + R2.simplify(); + if (R2.is_inexact()) + throw codegen_error("unknown constraint in loop bounds"); + if (known.is_null()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + else { + Relation R2_extended = copy(R2); + Relation known_extended = copy(known); + if (R2.n_set() > known.n_set()) + known_extended = Extend_Set(known_extended, R2.n_set()-known.n_set()); + else if (R2.n_set() < known.n_set()) + R2_extended = Extend_Set(R2_extended, known.n_set()-R2.n_set()); + if (Intersection(R2_extended, known_extended).is_upper_bound_satisfiable()) { + new_IS[maxStmt] = R2; + transformations[maxStmt] = T[stmt]; + statementInfo[maxStmt] = stmt_content[stmt]; + maxStmt++; + } + } + c.next(); + if (!c.live()) + break; + if(code_gen_debug) { + fprintf(DebugFile, "splitting iteration space for disjoint form\n"); + fprintf(DebugFile, "Original iteration space: \n"); + R.print_with_subs(DebugFile); + fprintf(DebugFile, "First conjunct: \n"); + R2.print_with_subs(DebugFile); + } + Relation remainder(R, *c); + c.next(); + while (c.live()) { + remainder = Union(remainder, Relation(R, *c)); + c.next(); + } + R = Difference(remainder, copy(R2)); + R.simplify(); + if(code_gen_debug) { + fprintf(DebugFile, "Remaining iteration space: \n"); + R.print_with_subs(DebugFile); + } + } + } + + // reset number of statements + stmts = maxStmt-1; + if(stmts == 0) + return ocg->CreateComment(1, "No points in any of the iteration spaces!"); + + // entend iteration spaces to maximum dimension + for (int stmt = 1; stmt <= stmts; stmt++) { + int old_dim = new_IS[stmt].n_set(); + if (old_dim < last_level) { + new_IS[stmt] = Extend_Set(new_IS[stmt], last_level-old_dim); + F_And *f_root = new_IS[stmt].and_with_and(); + for (int i = old_dim+1; i <= last_level; i++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(new_IS[stmt].set_var(i), 1); + h.update_const(posInfinity); + } + } + } + + // standarize the known condition + if(known.is_null()) { + known = Relation::True(last_level); + } + known = Extend_Set(known, last_level-known.n_set()); + for (int i = 1; i <= last_level; i++) + known.name_set_var(i, std::string("t")+to_string(i)); + known.setup_names(); + + // prepare projected subspaces for each loop level + projected_nIS.clear(); + projected_nIS.reallocate(last_level); + for(int i = 1; i <= last_level; i++ ) { + projected_nIS[i].reallocate(stmts); + } + for (int stmt = 1; stmt <= stmts; stmt++) { + if (last_level > 0) + projected_nIS[last_level][stmt] = new_IS[stmt]; + for (int i = last_level-1; i >= 1; i--) { + projected_nIS[i][stmt] = Project(copy(projected_nIS[i+1][stmt]), i+1, Set_Var); + projected_nIS[i][stmt].simplify(); + } + } + + // recursively generate AST + IntTuple allStmts(stmts); + for(int i = 1; i <= stmts; i++) + allStmts[i] = 1; + CG_result *cg = gen_recursive(1, allStmts); + + // always force finite bounds + cg = cg->recompute(known, known); + cg = cg->force_finite_bounds(); + + // loop overhead removal based on actual nesting depth -- by chun 09/17/2008 + for (int i = 1; i <= min(effort, cg->depth()); i++) + cg = cg->liftOverhead(i); + + // merge adjacent if-conditions -- by chun 10/24/2006 + cg->hoistGuard(); + + // really print out the loop + //CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector(last_level, NULL)); + CG_outputRepr* sRepr = cg->printRepr(ocg, 1, std::vector(last_level )); + delete cg; + cg = NULL; + projected_nIS.clear(); + transformations.clear(); + new_IS.clear(); + + return sRepr; +} + +CG_result *gen_recursive(int level, IntTuple &isActive) { + int stmts = isActive.size(); + + Set active; + int s; + for(s = 1; s <= stmts; s++) + if(isActive[s]) active.insert(s); + + assert (active.size() >= 1); + if(level > last_level) return new CG_leaf(isActive); + + if (active.size() == 1) + return new CG_loop(isActive,level, gen_recursive(level+1,isActive)); + + bool constantLevel = true; + + int test_rel_size; + coef_t start,finish; + finish = -(posInfinity-1); // -(MAXINT-1); + start = posInfinity; // MAXINT; + Tuple when(stmts); + for(s=1; s<=stmts; s++) if (isActive[s]) { + coef_t lb,ub; + test_rel_size = projected_nIS[level][s].n_set(); + projected_nIS[level][s].single_conjunct() + ->query_variable_bounds( + projected_nIS[level][s].set_var(level), + lb,ub); + if(code_gen_debug) { + fprintf(DebugFile, "IS%d: " coef_fmt " <= t%d <= " coef_fmt "\n",s, + lb,level,ub); + projected_nIS[level][s].prefix_print(DebugFile); + } + if (lb != ub) { + constantLevel = false; + break; + } + else { + set_max(finish,lb); + set_min(start,lb); + when[s] = lb; + } + } + + + if (constantLevel && finish-start <= stmts) { + IntTuple newActive(isActive.size()); + for(int i=1; i<=stmts; i++) + newActive[i] = isActive[i] && when[i] == start; + CG_result *r = new CG_loop(isActive,level, + gen_recursive(level+1,newActive)); + for(coef_t time = start+1; time <= finish; time++) { + int count = 0; + for(int i=1; i<=stmts; i++) { + newActive[i] = isActive[i] && when[i] == time; + if (newActive[i]) count++; + } + if (count) { + Relation test_rel(test_rel_size); + GEQ_Handle g = test_rel.and_with_GEQ(); + g.update_coef(test_rel.set_var(level),-1); + g.update_const(time-1); + + r = new CG_split(isActive,level,test_rel,r, + new CG_loop(isActive,level, + gen_recursive(level+1,newActive))); + } + } + return r; + } + +// Since the Hull computation is approximate, we will get regions that +// have no stmts. (since we will have split on constraints on the +// hull, and thus we are looking at a region outside the convex hull +// of all the iteration spaces.) +#if 1 + Relation hull = Hull(projected_nIS[level],isActive,1); +#else + Relation hull = Hull(projected_nIS[level],isActive,0); +#endif + + if(code_gen_debug) { + fprintf(DebugFile, "Hull (level %d) is:\n",level); + hull.prefix_print(DebugFile); + } + + + IntTuple firstChunk(isActive); + IntTuple secondChunk(isActive); + + //protonu-warn Chun about this change + //This does some fancy splitting of statements into loops with the + //fewest dimentions, but that's not necessarily what we want when + //code-gening for CUDA. smtNonSplitLevels keeps track per-statment of + //the levels that should not be split on. + bool checkForSplits = true; + for (int s = 1; s <= isActive.size(); s++){ + if (isActive[s]) { + if(s < smtNonSplitLevels.size() && smtNonSplitLevels[s].index(level-2) != 0){ + checkForSplits = false; + break; + } + } + } + + //protonu-modifying the next for loop + for (int s = 1; checkForSplits && s <= isActive.size(); s++) + if (isActive[s]) { + Relation gist = Gist(copy(projected_nIS[level][s]),copy(hull),1); + if (gist.is_obvious_tautology()) break; + gist.simplify(); + Conjunct *s_conj = gist.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + Relation test_rel(gist.n_set()); + test_rel.and_with_GEQ(*G); + Variable_ID v = set_var(level); + coef_t sign = (*G).get_coef(v); + if(sign > 0) test_rel = Complement(test_rel); + if(code_gen_debug) { + fprintf(DebugFile, "Considering split from stmt %d:\n",s); + test_rel.prefix_print(DebugFile); + } + + firstChunk[s] = sign <= 0; + secondChunk[s] = sign > 0; + int numberFirst = sign <= 0; + int numberSecond = sign > 0; + + for (int s2 = 1; s2 <= isActive.size(); s2++) + if (isActive[s2] && s2 != s) { + if(code_gen_debug) + fprintf(DebugFile,"Consider stmt %d\n",s2); + bool t = Intersection(copy(projected_nIS[level][s2]), + copy(test_rel)).is_upper_bound_satisfiable(); + bool f = Difference(copy(projected_nIS[level][s2]), + copy(test_rel)).is_upper_bound_satisfiable(); + assert(t || f); + if(code_gen_debug && t&&f) + fprintf(DebugFile, "Slashes stmt %d\n",s2); + if (t&&f) goto nextGEQ; + if(code_gen_debug) { + if (t) + fprintf(DebugFile, "true for stmt %d\n",s2); + else + fprintf(DebugFile, "false for stmt %d\n",s2); + } + if (t) numberFirst++; + else numberSecond++; + firstChunk[s2] = t; + secondChunk[s2] = !t; + } + + assert(numberFirst+numberSecond>1 && "Can't handle wildcard in iteration space"); + if(code_gen_debug) + fprintf(DebugFile, "%d true, %d false\n", + numberFirst, + numberSecond); + if (numberFirst && numberSecond) { + // Found a dividing constraint + return new CG_split(isActive,level,test_rel, + gen_recursive(level,firstChunk), + gen_recursive(level,secondChunk)); + } + nextGEQ: ; + } + } + + // No way found to divide stmts without splitting, generate loop + + return new CG_loop(isActive,level, gen_recursive(level+1,isActive)); +} + +} diff --git a/omega/code_gen/src/codegen.cc b/omega/code_gen/src/codegen.cc new file mode 100755 index 0000000..92ca702 --- /dev/null +++ b/omega/code_gen/src/codegen.cc @@ -0,0 +1,378 @@ +/***************************************************************************** + Copyright (C) 1994-2000 the Omega Project Team + Copyright (C) 2005-2011 Chun Chen + All Rights Reserved. + + Purpose: + CodeGen class as entry point for code generation. + + Notes: + Loop variable name prefix should not cause any possible name conflicts + with original loop variables wrapped in statement holder. This guarantees + that variable substitution done correctly in the generated code. + + History: + 04/24/96 MMGenerateCode, added by Fortran D people. Lei Zhou + 09/17/08 loop overhead removal based on actual nesting depth -- by chun + 03/05/11 fold MMGenerateCode into CodeGen class, Chun Chen +*****************************************************************************/ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace omega { + +const std::string CodeGen::loop_var_name_prefix = "t"; +const int CodeGen::var_substitution_threshold = 10; + +//Anand--adding stuff to make Chun's code work with Gabe's +std::vector< std::vector > smtNonSplitLevels; +std::vector< std::vector > loopIdxNames;//per stmt +std::vector< std::pair > syncs; + + + +CodeGen::CodeGen(const std::vector &xforms, const std::vector &IS, const Relation &known, std::vector< std::vector > smtNonSplitLevels_ , std::vector< std::vector > loopIdxNames_, std::vector< std::pair > syncs_) { + // check for sanity of parameters + int num_stmt = IS.size(); + if (xforms.size() != num_stmt) + throw std::invalid_argument("number of iteration spaces does not match number of transformations"); + known_ = copy(known); + if (known_.n_out() != 0) + throw std::invalid_argument("known condition must be a set relation"); + if (known_.is_null()) + known_ = Relation::True(0); + else + known_.simplify(2, 4); + if (!known_.is_upper_bound_satisfiable()) + return; + if (known_.number_of_conjuncts() > 1) + throw std::invalid_argument("only one conjunct allowed in known condition"); + xforms_ = xforms; + for (int i = 0; i < num_stmt; i++) { + xforms_[i].simplify(); + if (!xforms_[i].has_single_conjunct()) + throw std::invalid_argument("mapping relation must have only one conjunct"); + if (xforms_[i].n_inp() != IS[i].n_inp() || IS[i].n_out() != 0) + throw std::invalid_argument("illegal iteration space or transformation arity"); + } + + + //protonu-- + //easier to handle this as a global + smtNonSplitLevels = smtNonSplitLevels_; + syncs = syncs_; + loopIdxNames = loopIdxNames_; + //end-protonu + + + + // find the maximum iteration space dimension we are going to operate on + int num_level = known_.n_inp(); + for (int i = 0; i < num_stmt; i++) + if (xforms_[i].n_out() > num_level) + num_level = xforms_[i].n_out(); + known_ = Extend_Set(known_, num_level-known_.n_inp()); + for (int i = 1; i <= num_level; i++) + known_.name_set_var(i, loop_var_name_prefix + to_string(i)); + known_.setup_names(); + + // split disjoint conjunctions in original iteration spaces + std::vector new_IS; + for (int i = 0; i < num_stmt; i++) { + for (int j = 1; j <= IS[i].n_inp(); j++) + xforms_[i].name_input_var(j, const_cast &>(IS)[i].input_var(j)->name()); + for (int j = 1; j <= xforms_[i].n_out(); j++) + xforms_[i].name_output_var(j, loop_var_name_prefix + to_string(j)); + xforms_[i].setup_names(); + + Relation R = Range(Restrict_Domain(copy(xforms_[i]), copy(IS[i]))); + R = Intersection(Extend_Set(R, num_level-R.n_inp()), copy(known_)); + R.simplify(2, 4); + if (R.is_inexact()) + throw codegen_error("cannot generate code for inexact iteration spaces"); + + while(R.is_upper_bound_satisfiable()) { + DNF *dnf = R.query_DNF(); + DNF_Iterator c(dnf); + Relation R2 = Relation(R, *c); + R2.simplify(); + new_IS.push_back(copy(R2)); + remap_.push_back(i); + c.next(); + if (!c.live()) + break; + Relation remainder(R, *c); + c.next(); + while (c.live()) { + remainder = Union(remainder, Relation(R, *c)); + c.next(); + } + R = Difference(remainder, R2); + R.simplify(2, 4); + } + } + + // number of new statements after splitting + num_stmt = new_IS.size(); + if(!smtNonSplitLevels.empty()) + smtNonSplitLevels.resize(num_stmt); + // assign a dummy value to loops created for the purpose of expanding to maximum dimension + for (int i = 0; i < num_stmt; i++) { + if (xforms[remap_[i]].n_out() < num_level) { + F_And *f_root = new_IS[i].and_with_and(); + for (int j = xforms[remap_[i]].n_out()+1; j <= num_level; j++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(new_IS[i].set_var(j), 1); + h.update_const(posInfinity); + } + new_IS[i].simplify(); + } + } + + // calculate projected subspaces for each loop level once and save for CG tree manipulation later + projected_IS_ = std::vector >(num_level); + for (int i = 0; i < num_level; i++) + projected_IS_[i] = std::vector(num_stmt); + for (int i = 0; i < num_stmt; i++) { + if (num_level > 0) + projected_IS_[num_level-1][i] = new_IS[i]; + for (int j = num_level-1; j >= 1; j--) { + projected_IS_[j-1][i] = Project(copy(projected_IS_[j][i]), j+1, Set_Var); + projected_IS_[j-1][i].simplify(2, 4); + } + } +} + + +CG_result *CodeGen::buildAST(int level, const BoolSet<> &active, bool split_on_const, const Relation &restriction) { + if (level > num_level()) + return new CG_leaf(this, active); + + int num_active_stmt = active.num_elem(); + if (num_active_stmt == 0) + return NULL; + else if (num_active_stmt == 1) + return new CG_loop(this, active, level, buildAST(level+1, active, true, restriction)); + + // use estimated constant bounds for fast non-overlap iteration space splitting + if (split_on_const) { + std::vector, int> > bounds; + + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + Relation r = Intersection(copy(projected_IS_[level-1][*i]), copy(restriction)); + r.simplify(2, 4); + if (!r.is_upper_bound_satisfiable()) + continue; + coef_t lb, ub; + r.single_conjunct()->query_variable_bounds(r.set_var(level),lb,ub); + bounds.push_back(std::make_pair(std::make_pair(lb, ub), *i)); + } + sort(bounds.begin(), bounds.end()); + + std::vector split_cond; + std::vector split_child; + + coef_t prev_val = -posInfinity; + coef_t next_val = bounds[0].first.second; + BoolSet<> next_active(active.size()); + int i = 0; + while (i < bounds.size()) { + if (bounds[i].first.first <= next_val) { + next_active.set(bounds[i].second); + next_val = max(next_val, bounds[i].first.second); + i++; + } + else { + Relation r(num_level()); + F_And *f_root = r.add_and(); + if (prev_val != -posInfinity) { + GEQ_Handle h = f_root->add_GEQ(); + h.update_coef(r.set_var(level), 1); + h.update_const(-prev_val-1); + } + if (next_val != posInfinity) { + GEQ_Handle h = f_root->add_GEQ(); + h.update_coef(r.set_var(level), -1); + h.update_const(next_val); + } + r.simplify(); + + Relation new_restriction = Intersection(copy(r), copy(restriction)); + new_restriction.simplify(2, 4); + CG_result *child = buildAST(level, next_active, false, new_restriction); + if (child != NULL) { + split_cond.push_back(copy(r)); + split_child.push_back(child); + } + next_active.unset_all(); + prev_val = next_val; + next_val = bounds[i].first.second; + } + } + if (!next_active.empty()) { + Relation r = Relation::True(num_level()); + if (prev_val != -posInfinity) { + F_And *f_root = r.and_with_and(); + GEQ_Handle h = f_root->add_GEQ(); + h.update_coef(r.set_var(level), 1); + h.update_const(-prev_val-1); + r.simplify(); + } + Relation new_restriction = Intersection(copy(r), copy(restriction)); + new_restriction.simplify(2, 4); + CG_result *child = buildAST(level, next_active, false, new_restriction); + if (child != NULL) { + split_cond.push_back(copy(r)); + split_child.push_back(child); + } + } + + if (split_child.size() == 0) + return NULL; + else if (split_child.size() == 1) + return split_child[0]; + else + return new CG_split(this, active, split_cond, split_child); + } + // check bound conditions exhaustively for non-overlap iteration space splitting + else { + std::vector Rs(active.size()); + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + Rs[*i] = Intersection(Approximate(copy(projected_IS_[level-1][*i])), copy(restriction)); + Rs[*i].simplify(2, 4); + } + Relation hull = SimpleHull(Rs); + + //protonu-warn Chun about this change + //This does some fancy splitting of statements into loops with the + //fewest dimentions, but that's not necessarily what we want when + //code-gening for CUDA. smtNonSplitLevels keeps track per-statment of + //the levels that should not be split on. + bool checkForSplits = true; + for (BoolSet<>::const_iterator i = active.begin(); i != active.end(); i++) { + if(*i < smtNonSplitLevels.size()) + for(int k = 0; k ::const_iterator i = active.begin(); i != active.end() && checkForSplits; i++) { + Relation r = Gist(copy(Rs[*i]), copy(hull), 1); + if (r.is_obvious_tautology()) + continue; + r = EQs_to_GEQs(r); + + for (GEQ_Iterator e = r.single_conjunct()->GEQs(); e; e++) { + if ((*e).has_wildcards()) + continue; + + Relation cond = Relation::True(num_level()); + BoolSet<> first_chunk(active.size()); + BoolSet<> second_chunk(active.size()); + + if ((*e).get_coef(hull.set_var(level)) > 0) { + cond.and_with_GEQ(*e); + cond = Complement(cond);; + cond.simplify(); + second_chunk.set(*i); + } + else if ((*e).get_coef(hull.set_var(level)) < 0) { + cond.and_with_GEQ(*e); + cond.simplify(); + first_chunk.set(*i); + } + else + continue; + + bool is_proper_split_cond = true; + for (BoolSet<>::const_iterator j = active.begin(); j != active.end(); j++) + if ( *j != *i) { + bool in_first = Intersection(copy(Rs[*j]), copy(cond)).is_upper_bound_satisfiable(); + bool in_second = Difference(copy(Rs[*j]), copy(cond)).is_upper_bound_satisfiable(); + + if (in_first && in_second) { + is_proper_split_cond = false; + break; + } + + if (in_first) + first_chunk.set(*j); + else if (in_second) + second_chunk.set(*j); + } + + if (is_proper_split_cond && first_chunk.num_elem() != 0 && second_chunk.num_elem() != 0) { + CG_result *first_cg = buildAST(level, first_chunk, false, copy(cond)); + CG_result *second_cg = buildAST(level, second_chunk, false, Complement(copy(cond))); + if (first_cg == NULL) + return second_cg; + else if (second_cg == NULL) + return first_cg; + else { + std::vector split_cond; + std::vector split_child; + split_cond.push_back(copy(cond)); + split_child.push_back(first_cg); + split_cond.push_back(Complement(copy(cond))); + split_child.push_back(second_cg); + + return new CG_split(this, active, split_cond, split_child); + } + } + } + } + return new CG_loop(this, active, level, buildAST(level+1, active, true, restriction)); + } +} + + +CG_result *CodeGen::buildAST(int effort) { + if (remap_.size() == 0) + return NULL; + + CG_result *cgr = buildAST(1, ~BoolSet<>(remap_.size()), true, Relation::True(num_level())); + if (cgr == NULL) + return NULL; + + + // break down the complete iteration space condition to levels of bound/guard condtions + cgr = cgr->recompute(cgr->active_, copy(known_), copy(known_)); + + + + if (cgr == NULL) + return NULL; + + // calculate each loop's nesting depth + int depth = cgr->populateDepth(); + + + // redistribute guard condition locations by additional splittings + std::pair result = cgr->liftOverhead(min(effort,depth), false); + + // since guard conditions are postponed for non-loop levels, hoist them now. + // this enables proper if-condition simplication when outputting actual code. + result.first->hoistGuard(); + + + + + return result.first; +} + +} diff --git a/omega/code_gen/src/cscope.out b/omega/code_gen/src/cscope.out new file mode 100644 index 0000000..ac4e74f --- /dev/null +++ b/omega/code_gen/src/cscope.out @@ -0,0 +1,89773 @@ +cscope 15 $HOME/suif-cuda-omega-latest/code_gen/src 0000481316 + @CG.cc + +21  + ~ + +22  + ~ + +23  + ~ + +24  + ~ + +25  + ~ + +26  + ~ + +27  + ~ + +28  + ~ + +29  + ~ + +31 +mea + + gomega + { + +33 +Tue +< +Ri +> +w_IS +; + +34 +Tue + > +ojeed_nIS +; + +35 +Tue +< +CG_ouutRr + *> +emtInfo +; + +36 +Tue +< +Ri +> +sfmis +; + +37  +ϡ_v +; + +39 +CG_su + * +g_cursive +( +v +, +ITue + & +isAive +); + +43 +mea + + gomega + { + +45 +Tue +< +ITue +> +smtNSLevs +; + +46 +Tue + > +loIdxNames +; + +47 +d +:: +ve + > +syncs +; + +48  +checkLoLev +; + +49  +mtFLoCheck +; + +50  +uBoundFLev +; + +51  +lowBoundFLev +; + +52 +bo + +flInBounds +; + +58 + gd +:: +rg + +CG_su +:: +t +( +dt +) { + +59 +CG_rgBud + +ocg +; + +60 +CG_ouutRr + * + g + = +tRr +(& +ocg +, +dt +, + +61 +d +:: +ve +< +CG_ouutRr + *>( +ϡ_v +, + +62 +ic_ +< +CG_ouutRr + *>( +NULL +))); + +63 i( + g + = +NULL +) + +64  +d +:: +rg +(); + +66  +GSg +( + +); + +73 + gCG_l +:: +CG_l +( +ITue + & +aive +,  +lvl +, cڡ +Ri + & +cd_ +, + +74 +CG_su + * +T +, CG_su * +F +) { + +75 +Ri + + gcd + = +cy +( +cd_ +); + +76 +as +( +cd +. +has_sg_cjun +()); + +78 +cf_t + + gc + = 0; + +79  + gpos + = -1; + +80 +GEQ_It + +G +( +cd +. +sg_cjun +()); + +81 i( + gG +) { + +82  +Cڡr_Vs_Ir + +cvi +(* +G +, +l +); + gcvi +; cvi++) + +83 i((* + gcvi +). + gcf + && (*cvi). + gv +-> +kd +(= +Iut_V + + +84 && (* +cvi +). +v +-> +g_posi +(> +pos +) { + +85 +pos + = (* +cvi +). +v +-> +g_posi +(); + +86 + gc + = (* +cvi +). +cf +; + +89 #ide +NDEBUG + + +90 i( + gpos + > + glvl + + 1) { + +91 +rtf +( +DebugFe +, "Ieg slv%d\n", +lvl +); + +92 + gcd +. +efix_t +( +DebugFe +); + +93 + gcode_g_debug + = 1; + +97 +as +( +pos + =0 ||o< +lvl + + 1); + +99 i( + gpos + > 0 && + gc + > 0) { + +100 +CG_su + * + gfoo + = +T +; + +101 + gT + = +F +; + +102 + gF + = +foo +; + +103 i( + gcode_g_debug +) { + +104 +rtf +( +DebugFe +, + +105 "Revsg cu iw sodv%d\n", +lvl +); + +106 + gcd +. +efix_t +( +DebugFe +); + +108 + gcd + = +Comemt +( +cd +); + +110 + gcd +. +simify +(); + +112 +as +( +cd +. +has_sg_cjun +()); + +115 +as +( +EQ_It +( +cd +. +sg_cjun +())); + +117 + gisAive + = +aive +; + +118 + gcdi + = +cd +; + +119 + gv + = +lvl +; + +120 + gueCu + = +T +; + +121 + glCu + = +F +; + +124 + gd +:: +rg + +CG_l +:: +tSuu +( +dt +) { + +125 +d +:: +rg + +su + = +GIndtSs +( +dt +) + "// splitt " + +126 + +to_rg +((* +this ++ "\n" + +GIndtSs +( +dt +) + +127 + "// gud:" + +gud +. +t_fmu_to_rg +() + "\n" + +128 + +GIndtSs +( +dt +) + "// if " + +129 + +cdi +. +t_fmu_to_rg +() + "hen\n" + +130 + +ueCu +-> +tSuu +( +dt + + 1+ +GIndtSs +(indent) + +131 + "//l\n" + +lCu +-> +tSuu +( +dt + + 1); + +132  + gsu +; + +135 +CG_ouutRr +* + gCG_l +:: +tRr +( +CG_ouutBud +* +ocg +,  +dt +, + +136 cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +138 i(! +Mu_Be_Subt +( +cy +( +riis +), cy( +known +))) + +139 +tf +("------------wrong------------------\n"); + +141 +CG_ouutRr +* + gmtLi +; + +143 +CG_ouutRr + * + gRr + = +NULL +; + +144 i(! + ggud +. +is_nu +(&& !gud. +is_obvious_utogy +()) { + +145 + gRr + = +ouutGud +( +ocg +, +gud +, +assigd__the_y +); + +146 + gdt +++; + +148 i( + gRr + ! +NULL +) + +149 +mtLi + = +ocg +-> +CeIf +( +dt + - 1, +Rr +, + +150 +ueCu +-> +tRr +( +ocg +, +dt +, +assigd__the_y +), + +151 +lCu +-> +tRr +( +ocg +, +dt +, +assigd__the_y +)); + +153 + gmtLi + = +ocg +-> +StmtLiAd +( + +154 +ueCu +-> +tRr +( +ocg +, +dt +, +assigd__the_y +), + +155 +lCu +-> +tRr +( +ocg +, +dt +, +assigd__the_y +)); + +157  + gmtLi +; + +160 +CG_su + * + gCG_l +:: +liOvhd +( +dth +) { + +161 +as +( +dth + >= 1); + +162 + gueCu + = +ueCu +-> +liOvhd +( +dth +); + +163 + glCu + = +lCu +-> +liOvhd +( +dth +); + +164  + gthis +; + +167 +CG_su + * + gCG_l +:: +f_fe_bounds +() { + +168 +ueCu + =rueCu-> +f_fe_bounds +(); + +169 + glCu + = +lCu +-> +f_fe_bounds +(); + +170  + gthis +; + +173 +Ri + + gCG_l +:: +fdOvhd +( +liTo +) { + +174 +Ri + +r + = +ueCu +-> +fdOvhd +( +liTo +); + +175 i( + gr +. +is_obvious_utogy +()) + +176 + gr + = +lCu +-> +fdOvhd +( +liTo +); + +177  + gr +; + +180 +CG_su + * + gCG_l +:: +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +) { + +181 + gknown + = +cy +( +k +); + +182 + griis + = +cy +( +r +); + +184  + gnumAive + = 0; + +185  + gs + = 1; s < +isAive +. +size +(); s++) + +186 i( + gisAive +[ +s +]) { + +187 +Ri + + gI + = +ojeed_nIS +[ +v +][ +s +]; + +188 i(! +Ii +( +cy +( +riis +), +I +). +is_u_bound_tisfb +()) + +189 + gisAive +[ +s +] = 0; + +191 + gnumAive +++; + +193 i( + gnumAive + == 0) { + +194 +de + +this +; + +195  +w + + gCG_nu +; + +196 } i( + gnumAive + == 1 && 0) { + +199 +CG_su + * +cg + = +g_cursive +( +v +, +isAive +); + +200 + gcg + = +cg +-> +compu +( +k +, +r +); + +201 +de + + gthis +; + +202  + gcg +; + +205 +Ri + + gw_riis + = +Ii +( +cy +( +riis +), + +206 +cy +( +cdi +)); + +207 + gw_riis +. +simify +(); + +208 + gueCu + = +ueCu +-> +compu +( +known +, +w_riis +); + +209 + gw_riis + = +Difn +( +cy +( +riis +), cy( +cdi +)); + +210 + gw_riis +. +simify +(); + +211 + glCu + = +lCu +-> +compu +( +known +, +w_riis +); + +213 i( + gueCu +-> +isNu +()) { + +214 +CG_su + * + gcg + = +lCu +; + +215 + glCu + = +NULL +; + +216 +de + + gthis +; + +217  + gcg +; + +219 i( + glCu +-> +isNu +()) { + +220 +CG_su + * + gcg + = +ueCu +; + +221 + gueCu + = +NULL +; + +222 +de + + gthis +; + +223  + gcg +; + +225  + gthis +; + +228 +Ri + + gCG_l +:: +hoiGud +() { + +229 +Ri + +gud1 + = +ueCu +-> +hoiGud +(); + +230 +Ri + + ggud2 + = +lCu +-> +hoiGud +(); + +231 i( + ggud +. +is_nu +()) + +232 + ggud + = +Ri +:: +True +( +cdi +. +n_t +()); + +234 i(! + ggud1 +. +is_obvious_utogy +(&& ! + ggud2 +.is_obvious_tautology() + +235 && +Mu_Be_Subt +( +cy +( +gud1 +), cy( +gud2 +)) + +236 && +Mu_Be_Subt +( +cy +( +gud2 +), cy( +gud1 +))) { + +237 + gueCu +-> +moveGud +(); + +238 + glCu +-> +moveGud +(); + +239 + ggud + = +Ii +( +gud +, +gud1 +); + +242  + ggud +; + +249 +Ri + + gCG_af +:: +fdOvhd +( +liTo +) { + +250  +s + = 1; + gs + < +isAive +. +size +(); s++) + +251 i( + gisAive +[ +s +]) { + +252  + gbb + = ! +gud +[ +s +]. +is_obvious_utogy +(); + +253 i( + gbb +) { + +254 i( + gcode_g_debug +) + +255 +rtf +( +DebugFe +, + +257 +s +, +gud +[s]. +t_fmu_to_rg +(). +c_r +()); + +258 +Ri + + gr + = +pickOvhd +( +gud +[ +s +], +liTo +); + +259 i(! + gr +. +is_obvious_utogy +()) + +260  + gr +; + +263  + gRi +:: +True +( +known +. +n_t +()); + +266 + gd +:: +rg + +CG_af +:: +tSuu +() { + +267 +d +:: +rg + +su +; + +268  + gs + = 1; s < +isAive +. +size +(); s++) + +269 i( + gisAive +[ +s +]) { + +270 + gsu + + +d +:: +rg +("s"+ +to_rg +( +s +); + +272  + gsu + + "\n"; + +275 +CG_ouutRr +* + gCG_af +:: +tRr +( +CG_ouutBud +* +ocg +,  +dt +, + +276 cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +278 i(! +Mu_Be_Subt +( +cy +( +riis +), cy( +known +))) + +279 +tf +("------------wrong------------------\n"); + +281 + gd +:: +rg + +su +; + +282 +CG_ouutRr +* + gmtLi + = +NULL +; + +283 +CG_ouutRr +* + gmtNode + = +NULL +; + +285 + gTue +<> + gwkg +; + +287 i( + gcode_g_debug + > 1) { + +288 + gsu + = "known: " + +known +. +t_fmu_to_rg +(); + +289 + gmtLi + = +ocg +-> +StmtLiAd +( +mtLi +, + +290 +ocg +-> +CeCommt +( +dt +, +su +)); + +293  + gs + = 1; s < +isAive +. +size +(); s++) + +294 i( + gisAive +[ +s +]) { + +295 i( + ggud +[ +s +]. +is_obvious_utogy +()) { + +296 + gmtNode + = +ouutSmt +( +ocg +, +emtInfo +[ +s +]-> +e +(), + +297 +dt +, +sfmis +[ +s +], +known +, +assigd__the_y +); + +298 + gmtLi + = +ocg +-> +StmtLiAd +( +mtLi +, +mtNode +); + +300 i( + gcode_g_debug + > 1) { + +301 + gsu + = "restrictions: " + +302 + +riis +. +t_fmu_to_rg +(); + +303 + gmtLi + = +ocg +-> +StmtLiAd +( +mtLi +, + +304 +ocg +-> +CeCommt +( +dt +, +su +)); + +306 + gwkg +. +nd +( +s +); + +311  + gi + = 1; i < +wkg +. +size +(); i++) + +312 i( + gwkg +[ +i +] != 0) { + +313 +Ri + +g + = +Ii +( +cy +( +gud +[ +wkg +[ +i +]]), cy( +known +)); + +314 + gmtNode + = +ouutSmt +( +ocg +, +emtInfo +[ +wkg +[ +i +]]-> +e +(), + +315 +dt + + 1, +sfmis +[ +wkg +[ +i +]], +g +, + +316 +assigd__the_y +); + +318  + gj + = +i + + 1; j < +wkg +. +size +(); j++) + +319 i( + gwkg +[ +j +] != 0) { + +320 i( +Mu_Be_Subt +( +cy +( +gud +[ +wkg +[ +i +]]), + +321 +cy +( +gud +[ +wkg +[ +j +]])) + +322 && +Mu_Be_Subt +( +cy +( +gud +[ +wkg +[ +j +]]), + +323 +cy +( +gud +[ +wkg +[ +i +]]))) { + +324 +mtNode + = +ocg +-> +StmtLiAd +(stmtNode, + +325 +ouutSmt +( +ocg +, + +326 +emtInfo +[ +wkg +[ +j +]]-> +e +(), + +327 +dt + + 1, +sfmis +[ +wkg +[ +j +]], + +328 +g +, +assigd__the_y +)); + +329 + gwkg +[ +j +] = 0; + +333 +CG_ouutRr + * + gifGud + = +ouutGud +( +ocg +, +gud +[ +wkg +[ +i +]], + +334 +assigd__the_y +); + +335 + gmtNode + = +ocg +-> +CeIf +( +dt +, +ifGud +, +mtNode +, +NULL +); + +336 + gmtLi + = +ocg +-> +StmtLiAd +( +mtLi +, +mtNode +); + +339  + gmtLi +; + +342 +CG_su +* + gCG_af +:: +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +) { + +343 + gknown + = +cy +( +k +); + +344 + griis + = +cy +( +r +); + +346 + ggud +. +lo +( +isAive +. +size +()); + +348 +bo + + gyAive + = +l +; + +349  + gs + = 1; s < +isAive +. +size +(); s++) + +350 i( + gisAive +[ +s +]) { + +351 +Ri + + gI + = +Ii +( +cy +( +riis +), cy( +w_IS +[ +s +])); + +352 i(! + gI +. +is_u_bound_tisfb +()) + +353 + gisAive +[ +s +] = 0; + +355 + gyAive + = +ue +; + +356 +as +(! +I +. +is_nu +()); + +357 + ggud +[ +s +] = +Gi +( +cy +( +I +), cy( +known +), 1); + +363 i(! + gyAive +) { + +364 +de + + gthis +; + +365  +w + +CG_nu +(); + +367  + gthis +; + +370 +Ri + + gCG_af +:: +hoiGud +() { + +371  +s +; + +372  + gs + = 1; s < +isAive +. +size +(&& !isAive[ +s +]; s++) + +375 i( + gs + > + gisAive +. +size +()) + +376  + gRi +:: +True +(1); + +378 +Ri + + ggud1 + = +gud +[ +s +]; + +380  + gi + = +s + + 1; i < +isAive +. +size +(); i++) + +381 i( + gisAive +[ +i +] + +382 && !( +Mu_Be_Subt +( +cy +( +gud1 +), cy( +gud +[ +i +])) + +383 && +Mu_Be_Subt +( +cy +( +gud +[ +i +]), cy( +gud1 +)))) + +384  + gRi +:: +True +( +gud1 +. +n_t +()); + +386  + ggud1 +; + +389  + gCG_af +:: +moveGud +() { + +390  +i + = 1; + gi + < +isAive +. +size +(); i++) + +391 i( + gisAive +[ +i +]) + +392 + ggud +[ +i +] = +Ri +:: +True +( +gud +[i]. +n_t +()); + +399 +CG_su + * + gCG_lo +:: +f_fe_bounds +() { + +400 i(! +edLo + + +401 || ( +hasBound +( +bounds +, +v +, 0) && hasBound(bounds,evel, 1))) { + +402 + gbody + = +body +-> +f_fe_bounds +(); + +403  + gthis +; + +406 i( + gcode_g_debug +) + +407 +rtf +( +DebugFe +, "Don't have finite bounds in:\n%s\n\n", + +408 +this +-> +t +(2). +c_r +()); + +409 +bo + + gbb + = ! +hasBound +( +bounds +, +v +, 0); + +410  + gdei + = +bb + ? 0 : 1; + +411  + gs +; + +412 +Ri + + gS +; + +413  + gs + = 1; s < +isAive +. +size +(); s++) + +414 i( + gisAive +[ +s +]) + +415 i( +fd_y_cڡt +( +s +, +v +, +riis +, +dei +, +S +, + +416 +l +)) + +420 i( + gS +. +is_nu +()) + +421  + gs + = 1; s < +isAive +. +size +(); s++) + +422 i( + gisAive +[ +s +]) + +423 i( +fd_y_cڡt +( +s +, +v +, +riis +, +dei +, +S +, + +424 +ue +)) + +427 i( + gS +. +is_nu +()) { + +429 +rtf +( +DebugFe +,"hasBound(%s,%d,%sid f, buovhd wautogy\n", +I +. +t_fmu_to_rg +(). +c_r +(), +v +, +dei +?"upper bound":"lower bound"); + +431 +throw + +codeg_r +("unableo force finite bounds"); + +436 +tf +("Sg o%s\n", +S +. +t_fmu_to_rg +(). +c_r +()); + +438 +CG_su + * + gl + = +w + +CG_l +( +isAive +, +v +, +S +, +this +,his-> +e +()); + +439 + gl + = +l +-> +compu +( +cy +( +known +), cy( +riis +)); + +441 i( + gcode_g_debug +) + +442 +rtf +( +DebugFe +,"S ot fbounds:\n%s\n\n", +l +-> +t +(2). +c_r +()); + +444  + gl +-> +f_fe_bounds +(); + +447 +CG_su + * + gCG_lo +:: +liOvhd +( +dth +) { + +448 +as +( +dth + >= 1); + +449 i( + gthis +-> +dth +(< + gdth +) + +450  + gthis +; + +451 i(!( + gedLo + && + gthis +-> +dth +() == depth)) { + +452 +body + = body-> +liOvhd +( +dth +); + +453  + gthis +; + +456 +Ri + + gc + = +body +-> +fdOvhd +( +v +); + +457 i( + gc +. +is_obvious_utogy +()) + +458  + gthis +; + +459 +as +( +c +. +is_u_bound_tisfb +()); + +460 + gd +:: +rg + +befe +; + +461 i( + gcode_g_debug +) { + +462 + gbefe + = +t +(1); + +464 +CG_su + * + gs + = +w + +CG_l +( +isAive +, +v +, +c +, +this +,his-> +e +()); + +466 + gs + = +s +-> +compu +( +cy +( +known +), cy( +riis +)); + +467 i( + gcode_g_debug +) { + +468 + gd +:: +rg + +a + = +s +-> +t +(1); + +469 +rtf +( +DebugFe +, "Lifted out overhead of %s\n", + +470 +c +. +t_fmu_to_rg +(). +c_r +()); + +471 +rtf +( +DebugFe +, "om:\n%s\n", +befe +. +c_r +()); + +472 +rtf +( +DebugFe +, "tg:\n%s--\n", +a +. +c_r +()); + +474 + gs + = +s +-> +liOvhd +( +dth +); + +475  + gs +; + +478 + gd +:: +rg + +CG_lo +:: +tSuu +( +dt +) { + +479 +d +:: +rg + +s + = ""; + +480  + gd + = +dt +; + +481 + gs + + +GIndtSs +( +dt ++ "//o" + ( +edLo + ? "" : "(single)") + +482 + " f܁" + +to_rg +( +v ++ "" +o_rg((* +this +) + +484 + gs + + +GIndtSs +( +dt +) + "// known: " + +485 + +known +. +t_fmu_to_rg +() + "\n"; + +486 + gs + + +GIndtSs +( +dt +) + "// guard: " + +487 + +gud +. +t_fmu_to_rg +() + "\n"; + +488 + gs + + +GIndtSs +( +dt +) + "// bounds: " + +489 + +bounds +. +t_fmu_to_rg +() + "\n"; + +492  + gi + = 1; i < +isAive +. +size +(); i++) + +493 i( + gisAive +[ +i +]) { + +494 + gs + + +GIndtSs +( +dt ++ "// " + "s" + +to_rg +( +i +) + ":" + +495 + +ojeed_nIS +[ +v +][ +i +]. +t_fmu_to_rg +() + "\n"; + +498  + gs + + + gbody +-> +tSuu +( +d + + 1+ +GIndtSs +(indnt + 1) + +502 +CG_ouutRr +* + gCG_lo +:: +tRr +( +CG_ouutBud +* +ocg +,  +dt +, + +503 cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +505 i(! +Mu_Be_Subt +( +cy +( +riis +), cy( +known +))) + +506 +tf +("------------wrong------------------\n"); + +529 +CG_ouutRr +* + ggudRr + = +ouutGud +( +ocg +, +gud +, +assigd__the_y +); + +530 +Ri + + gfd + = +Ii +( +cy +( +known +), cy( +gud +)); + +531 + gfd +. +simify +(); + +536 + gd +:: +ve +< +CG_ouutRr + *> +af + = +assigd__the_y +; + +538 + gd +:: + +< +CG_ouutRr + *, + gbo +> + geqRr + = +ouutAssignmt +( +ocg +, +bounds +, + +539 +bounds +. +t_v +( +v +), +fd +, +gudRr +, +af +); + +540 i(! + geqRr +. + gcd +) + +541 + gaf +[ +v + - 1] = +eqRr +. +f +; + +543  + gd + = +dt +; + +544 i( + ggudRr + ! +NULL +) + +545 +d +++; + +548 i( + gcheckLoLev +) { + +549 i( + gv + = +checkLoLev +) { + +550 +bo + +mtP + = +l +; + +551  + gs + = 1; s < +isAive +. +size +(); s++) { + +552 i( + gisAive +[ +s +] && + gs + - 1 = +mtFLoCheck +) + +553 +mtP + = +ue +; + +555 i( + gmtP +) { + +556 + gflInBounds + = +ue +; + +563 + gd +:: + +< +CG_ouutRr + *, + gbo +> + gRr + = +ouutBounds +( +ocg +, +bounds +, + +564 +bounds +. +t_v +( +v +), +d +, +fd +, +af +); + +567 + gflInBounds + = +l +; + +570 +Ri + + g_ov + = +Gi +( +cy +( +bounds +), cy( +fd +), 1); + +572 i(! + g_ov +. +is_obvious_utogy +()) + +573 +tf +("=============something wrong===============\n"); + +575 +CG_ouutRr + * + gloRr + = +NULL +; + +576 i( + geqRr +. + gcd +) { + +577 +CG_ouutRr + * + gbodyRr + = +body +-> +tRr +( +ocg +, +d +, +af +); + +578 +CG_ouutRr + * + gassignRr + = +ocg +-> +CeAssignmt +( +d +, + +579 +ocg +-> +CeIdt +( +bounds +. +t_v +( +v +)-> +me +()), +eqRr +. +f +); + +580 + gloRr + = +ocg +-> +StmtLiAd +( +assignRr +, +bodyRr +); + +581 } i( + gRr +. + gcd +) { + +582 +CG_ouutRr + * + gbodyRr + = +body +-> +tRr +( +ocg +, +d + + 1, +af +); + +583 + gloRr + = +ocg +-> +CeLo +( +d +, +Rr +. +f +, +bodyRr +); + +585 #ifde +BUILDCUDA + + +591 +bo + + gblockLo + = +l +; + +592 +bo + + gthadLo + = +l +; + +593 +bo + + gsync + = +l +; + +594  + gfAiveStmt + = -1; + +595  + gs + = 1; s < +isAive +. +size +(); s++) { + +596 i( + gisAive +[ +s +]) { + +597 i( + gfAiveStmt + < 0) + +598 + gfAiveStmt + = +s +; + +602  + gidx + = +smtNSLevs +[ +s +]. +dex +( +v +); + +603 i( + gidx + == 1) { + +604 +blockLo + = +ue +; + +607 i( + gidx + == 2) { + +608 +thadLo + = +ue +; + +612 i( + gblockLo + && + gthadLo +) { + +613 +rtf +( +dr +, + +615 +v +); + +616 + gthadLo + = +l +; + +618 + gd +:: +rg + +eedIdx +; + +619 i( + gloIdxNames +. +size +() + +620 && ( + gv + / 2- 1 < + gloIdxNames +[ +fAiveStmt +]. +size +()) + +621 + geedIdx + = +loIdxNames +[ +fAiveStmt +][( +v + / 2)]; + +622  + gs + = 1; s < +isAive +. +size +(); s++) { + +623 i( + gisAive +[ +s +]) { + +624  + gi + = 0; i < + gsyncs +. +size +(); i++) { + +625 i( + gsyncs +[ +i +]. + gf + = +s + - 1 + +626 && +rcmp +( +syncs +[ +i +]. +cd +. +c_r +(), + +627 +eedIdx +. +c_r +()) == 0) { + +628 +sync + = +ue +; + +634 i( + gthadLo + || + gblockLo + || + geedIdx +. +ngth +() != 0) { + +635  +buf +[1024]; + +636 + gd +:: +rg + +lo +; + +637 i( + gblockLo +) + +638 + glo + = "blockLoop "; + +639 i( + gthadLo +) + +640 + glo + = "threadLoop "; + +641 i( + geedIdx +. +ngth +(!0 && +sync +) { + +642 +rtf +( +buf +, "~cuda~ %edIdx: %sync", +lo +. +c_r +(), + +643 +eedIdx +. +c_r +()); + +644 } i( + geedIdx +. +ngth +() != 0) { + +645 +rtf +( +buf +, "~cuda~ %edIdx: %s", +lo +. +c_r +(), + +646 +eedIdx +. +c_r +()); + +648 +rtf +( +buf +, "~cuda~ %s", +lo +. +c_r +()); + +651 #ifde +BUILD_ROSE + + +652 + gloRr + = +ocg +-> +CeAribu +( +loRr +, +buf +); + +658 + gloRr + = +ocg +-> +StmtLiAd +(ocg-> +CeCommt +( +d +, +buf +), + +659 +loRr +); + +668 } i( + gRr +. + gf + ! +NULL +) { + +669 +CG_ouutRr + * +bodyRr + = +body +-> +tRr +( +ocg +, +d +, +af +); + +670 + gloRr + = +ocg +-> +StmtLiAd +( +Rr +. +f +, +bodyRr +); + +672 + gloRr + = +body +-> +tRr +( +ocg +, +d +, +af +); + +674 i( + ggudRr + ! +NULL +) + +675 +loRr + = +ocg +-> +CeIf +( +dt +, +gudRr +,oRr, +NULL +); + +677 +de + + gaf +[ +v + - 1]; + +678  + gloRr +; + +757 +Ri + + gCG_lo +:: +fdOvhd +( +liTo +) { + +760 i( +edLo +) { + +761  +bb + = ! +gud +. +is_obvious_utogy +(); + +762 i( + gbb +) { + +764 +rtf +( +DebugFe +,"Tryingoemove overhead on guard ofoop %xtevel %d: %s\n", + +765 (* +this +, +v +, +gud +. +t_fmu_to_rg +(). +c_r +()); + +767 +Ri + + gr + = +pickOvhd +( +gud +, +liTo +); + +768 i(! + gr +. +is_obvious_utogy +()) + +769  + gr +; + +771 +Ri + + gb + = +bounds +; + +772 +Ri + + gr + = +mMaxOvhd +( +b +, +v +); + +773 i(! + gr +. +is_obvious_utogy +()) { + +775 +rtf +( +DebugFe +,"Tryingoemove minMax overhead on guard ofoop %xtevel %d: %s\n", + +776 (* +this +, +v +, +gud +. +t_fmu_to_rg +(). +c_r +()); + +778  + gr +; + +781 +Ri + + gr + = +body +-> +fdOvhd +( +liTo +); + +782 i( + gr +. +is_obvious_utogy +()) + +783  + gr +; + +797 + gr + = +Ii +( +r +, +cy +( +bounds +)); + +799 + gr + = +oje_to_vs +( +r +, +v +, 0); + +801 + gr + = +Gi +( +r +, +cy +( +bounds +), 1); + +804  + gr +; + +807 +CG_su + * + gCG_lo +:: +compu +(cڡ +Ri + & +k +, cڡ Ri & +r +) { + +808 + gknown + = +cy +( +k +); + +809 + griis + = +cy +( +r +); + +813 +bo + + gyAive + = +l +; + +814  + gs + = 1; s < +isAive +. +size +(); s++) + +815 i( + gisAive +[ +s +]) { + +816 i(! +Ii +( +cy +( +riis +), + +817 +cy +( +ojeed_nIS +[ +v +][ +s +])). +is_u_bound_tisfb +()) { + +818 + gisAive +[ +s +] = 0; + +820 + gyAive + = +ue +; + +823 i(! + gyAive +) { + +824 +de + + gthis +; + +825  +w + +CG_nu +(); + +832 +Ri + + ghu + = +Hu +( +ojeed_nIS +[ +v +], +isAive +, 1, +ue +, + +833 +cy +( +riis +)); + +834 + ghu + = +Ii +( +hu +, +cy +( +riis +)); + +835 + ghu +. +simify +(2, 4); + +838 + gedLo + = +ue +; + +839  +EQ_It + + ge + = +hu +. +sg_cjun +()-> +EQs +();;++) { + +840 i(!(* + ge +). +has_wdrds +(&& (*e). +g_cf +( +hu +. +t_v +( +v +)) != 0) { + +841 +edLo + = +l +; + +842 + gbounds + = +Ri +:: +True +( +hu +. +n_t +()); + +843 + gbounds +. +d_wh_EQ +(* +e +); + +844 + gbounds +. +simify +(); + +845 + gbounds +. +cy_mes +( +hu +); + +846 + gbounds +. +tup_mes +(); + +852 i( + gedLo +) { + +853 + ghu + = +Gi +( +hu +, +cy +( +known +), 1); + +854 +Ri + + gb + = +hu +; + +856 + gbounds + = +Ri +( +hu +. +n_t +()); + +857 +F_Exis + * + g + = +bounds +. +add_d +()-> +add_exis +(); + +858 +F_And + * + gf_ro + = + +-> +add_d +(); + +861 +bo + + ghas_uesved_bound + = +l +; + +863 +Cjun + * + gc + = +b +. +sg_cjun +(); + +864 +Vb_ID + + gv + = +b +. +t_v +( +v +); + +865 + gd +:: +m + < +Vb_ID +, + gVb_ID + > + gexis_mpg +; + +866 + gd +:: +ack + < +d +:: + +< +GEQ_Hd +, + gVb_ID +> > + go_geq_ack +; + +867 + gd +:: +t + < +Vb_ID + > +o_v_t +; + +870  +GEQ_It + +gi +( +c +); + ggi +; gi++) + +871 i((* + ggi +). +g_cf +( +v +) != 0) { + +872 +bo + +is__of_bound + = +ue +; + +873 +GEQ_Hd + + gh2 +; + +874  +Cڡr_Vs_Ir + +cvi +(* +gi +, +ue +); + gcvi +; cvi++) + +875 i(! +fdFloIquy +( +b +, +cvi +. +cu_v +(), +h2 +, +v +)) { + +876 + ghas_uesved_bound + = +ue +; + +877 + gis__of_bound + = +l +; + +880 i(! + gis__of_bound +) + +883 +GEQ_Hd + + gh + = +f_ro +-> +add_GEQ +(); + +884  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) { + +885 +Vb_ID + + gv2 + = +cvi +. +cu_v +(); + +886  + gv2 +-> +kd +()) { + +887  + gIut_V +: { + +888  +pos + = +v2 +-> +g_posi +(); + +889 + gh +. +upde_cf +( +bounds +. +t_v +( +pos +), +cvi +. +cu_cf +()); + +892  + gExis_V +: + +893  +Wdrd_V +: { + +894 +d +:: +m +< +Vb_ID +, + gVb_ID +>:: + + +p + = + +895 +exis_mpg +. +fd +( +v2 +); + +896 +Vb_ID + + ge +; + +897 i( + gp + = +exis_mpg +. +d +()) { + +898 +e + = + +-> +dee +(); + +899 + gexis_mpg +[ +v2 +] = +e +; + +901 + ge + = (* +p +). +cd +; + +902 + gh +. +upde_cf +( +e +, +cvi +. +cu_cf +()); + +904 i( + go_v_t +. +fd +( +v2 += +o_v_t +. +d +()) { + +905 +fdFloIquy +( +b +, +v2 +, +h2 +, +v +); + +906 + go_geq_ack +. +push +( +d +:: +make_ +( +h2 +, +v2 +)); + +907 + go_v_t +. + +( +v2 +); + +911  + gGlob_V +: { + +912 +Glob_V_ID + +g + = +v2 +-> +g_glob_v +(); + +913 +Vb_ID + + gv3 +; + +914 i( + gg +-> +y +() == 0) + +915 +v3 + = +bounds +. +g_lol +( +g +); + +917 + gv3 + = +bounds +. +g_lol +( +g +, +v2 +-> +funi_of +()); + +918 + gh +. +upde_cf +( +v3 +, +cvi +. +cu_cf +()); + +922 +as +(0); + +925 + gh +. +upde_cڡ +((* +gi +). +g_cڡ +()); + +929 ! + go_geq_ack +. +emy +()) { + +930 + gd +:: + + < +GEQ_Hd +, + gVb_ID + > + gp + = +o_geq_ack +. +t +(); + +931 + go_geq_ack +. +p +(); + +933 +GEQ_Hd + + gh1 + = +f_ro +-> +add_GEQ +(); + +934 +GEQ_Hd + + gh2 + = +f_ro +-> +add_GEQ +(); + +935  +Cڡr_Vs_Ir + +cvi +( +p +. +f +); + gcvi +; cvi++) { + +936 +Vb_ID + + gv2 + = (* +cvi +). +v +; + +937  + gv2 +-> +kd +()) { + +938  + gIut_V +: { + +939  +pos + = +v2 +-> +g_posi +(); + +940 + gh1 +. +upde_cf +( +bounds +. +put_v +( +pos +), +cvi +. +cu_cf +()); + +941 + gh2 +. +upde_cf +( +bounds +. +put_v +( +pos +), - +cvi +. +cu_cf +()); + +944  + gExis_V +: + +945  +Wdrd_V +: { + +946 +d +:: +m +< +Vb_ID +, + gVb_ID +>:: + + +p2 + = + +947 +exis_mpg +. +fd +( +v2 +); + +948 +Vb_ID + + ge +; + +949 i( + gp2 + = +exis_mpg +. +d +()) { + +950 +e + = + +-> +dee +(); + +951 + gexis_mpg +[ +v2 +] = +e +; + +953 + ge + = (* +p2 +). +cd +; + +954 + gh1 +. +upde_cf +( +e +, +cvi +. +cu_cf +()); + +955 + gh2 +. +upde_cf +( +e +, - +cvi +. +cu_cf +()); + +957 i( + go_v_t +. +fd +( +v2 += +o_v_t +. +d +()) { + +958 +GEQ_Hd + +h3 +; + +959 +fdFloIquy +( +b +, +v2 +, +h3 +, +v +); + +960 + go_geq_ack +. +push +( +d +:: +make_ +( +h3 +, +v2 +)); + +961 + go_v_t +. + +( +v2 +); + +965  + gGlob_V +: { + +966 +Glob_V_ID + +g + = +v2 +-> +g_glob_v +(); + +967 +Vb_ID + + gv3 +; + +968 i( + gg +-> +y +() == 0) + +969 +v3 + = +bounds +. +g_lol +( +g +); + +971 + gv3 + = +bounds +. +g_lol +( +g +, +v2 +-> +funi_of +()); + +972 + gh1 +. +upde_cf +( +v3 +, +cvi +. +cu_cf +()); + +973 + gh2 +. +upde_cf +( +v3 +, - +cvi +. +cu_cf +()); + +977 +as +(0); + +980 + gh1 +. +upde_cڡ +( +p +. +f +. +g_cڡ +()); + +981 + gh2 +. +upde_cڡ +(- +p +. +f +. +g_cڡ +()); + +982 + gh2 +. +upde_cڡ +(- +p +. +f +. +g_cf +. +cd +) - 1); + +985 i( + ghas_uesved_bound +) { + +986 + gb + = +Aroxime +( +b +); + +987 + gb +. +simify +(); + +988 + gc + = +b +. +sg_cjun +(); + +990  +GEQ_It + +gi +( +c +); + ggi +; gi++) + +991 i((* + ggi +). +g_cf +( +v +) != 0) + +992 +f_ro +-> +add_GEQ +(* +gi +); + +996 +Ri + + gthe_gcs + = +ge_comm_ +( +ojeed_nIS +[ +v +], +isAive +, + +997 +v +, +known +); + +998 + gbounds + = +Ii +( +bounds +, +cy +( +the_gcs +)); + +999 + gbounds +. +simify +(); + +1000 + gbounds +. +cy_mes +( +hu +); + +1001 + gbounds +. +tup_mes +(); + +1005 i( + gedLo +) { + +1006 + ggud + = +Gi +( +cy +( +hu +), cy( +bounds +)); + +1007 + ggud + = +Proje +( +gud +, gud. +t_v +( +v +)); + +1008 + ggud + = +Gi +( +gud +, +cy +( +known +)); + +1009 + ggud +. +simify +(); + +1014 + ggud + = +Ri +:: +True +( +hu +. +n_t +()); + +1016 + ggud +. +cy_mes +( +hu +); + +1017 + ggud +. +tup_mes +(); + +1020 +Ri + + gfd + = +Ii +( +cy +( +bounds +), cy( +gud +)); + +1021 + gfd +. +simify +(); + +1022 +Ri + + gw_known + = +Ii +( +cy +( +known +), cy( +fd +)); + +1023 + gw_known +. +simify +(); + +1024 +Ri + + gw_riis + = +Ii +( +cy +( +riis +), + +1025 +cy +( +fd +)); + +1026 + gw_riis +. +simify +(); + +1027 + gbody + = +body +-> +compu +( +w_known +, +w_riis +); + +1028  + gthis +; + +1031 +Ri + + gCG_lo +:: +hoiGud +() { + +1032 +Ri + +r + = +body +-> +hoiGud +(); + +1033 i(! + gr +. +is_obvious_utogy +()) { + +1035 +bo + + g + = +l +; + +1036  +DNF_It + +di +( +r +. +quy_DNF +()); + gdi +; di++) { + +1037  +GEQ_It + +gi +((* +di +)-> +GEQs +()); + ggi +; gi++) + +1038 i((* + ggi +). +g_cf +( +r +. +t_v +( +v +)) != 0) { + +1039 + + = +ue +; + +1042 i( + g +) + +1045  +EQ_It + +ei +((* +di +)-> +EQs +()); + gei +;i++) + +1046 i((* + gei +). +g_cf +( +r +. +t_v +( +v +)) != 0) { + +1047 + + = +ue +; + +1050 i( + g +) + +1054 i(! + g +) { + +1055 + gbody +-> +moveGud +(); + +1056 + ggud + = +Ii +( +gud +, +r +); + +1062 i( + gedLo +) + +1063  + gRi +:: +True +( +bounds +. +n_t +()); + +1065  + ggud +; + + @CG_roseBuilder.cc + +15  + ~ + +16  + ~ + +17  + ~ + +19  + g_r +: +public + +d +:: +ruime_r + { + +20 +_r +(cڡ +d +:: +rg + & +msg +) : + +21 +d +:: +ruime_r +( +msg +) { + +25 +usg + +mea + + gSageBud +; + +26 +usg + +mea + + gSageI +; + +27 +usg + +mea + + gOmpSut +; + +29 +mea + + gomega + { + +34 * + gk_ocg_commt +; + +52 + gCG_roBud +:: +CG_roBud +( +SgGlob +* +glob +, SgGlob* +fSce +, + +53 +SgSymbTab +* +symb +, SgSymbTab* +symb2 +, +SgNode +* +ro +) : + +54 +glob_ +( +glob +), +glob_sce +( +fSce +), +symb_ +( +symb +), +symb2_ +( + +55 +symb2 +), +ro_ +( +ro +) { + +58 + gCG_roBud +::~ +CG_roBud +() { + +64 +CG_ouutRr +* +CG_roBud +:: +CePHd +(, CG_ouutR* +mt +, + +65 +Tue +< +CG_ouutRr +*> & +funcLi +, Tue< +d +:: +rg +> & +lo_vs +) const { + +67 +SgSmtPLi +* +li + = +ic_ +< +CG_roRr + *>( +mt +)-> +li_ +; + +68 +SgNode + * + gl +; + +69 +SgSmt +* + gemt +; + +70 i( + gli + ! +NULL +) { + +73 +de + +mt +; + +74  + gi + = 1; i < +funcLi +. +size +(); i++) { + +76 i(( + gfuncLi +[ +i +] = +NULL +&& (< +funcLi +. +size +())) + +78 i(( + gfuncLi +[ +i +] = +NULL +&& (= +funcLi +. +size +())) + +81 +CG_roRr + * + g + = +ic_ +( +funcLi +[ +i +]); + +82 +SgExessi +* + g + = + +-> +_ +; + +84  + gSgSmtPLi +:: + + + + = (* +li +). +beg +(); + +85 + g + !(* +li +). +d +(); it++) { + +86 + gemt + = (* + +); + +87 + gl + = +isSgNode +( +emt +); + +91  + gj +; + +92  + gn__symb_ +; + +94 + gn__symb_ + = 0; + +96 +SgVbSymb + * + gvs + = +symb_ +-> +fd_vb +( + +97 +SgName +( +lo_vs +[ +i +]. +c_r +())); + +99 i( + gvs + = +NULL +) { + +101 +n__symb_ + = 1; + +103 + gvs + = +symb2_ +-> +fd_vb +( +SgName +( +lo_vs +[ +i +]. +c_r +())); + +105 i( + gvs + ! +NULL +) { + +109 +d +:: +ve +< +SgVRefExp + *> +y + = +subu +( +l +, + +110 (cڡ +SgVbSymb +* +vs +, + +, +ro_ +); + +111  + gd +:: +ve +< +SgVRefExp + *>:: + + + + = + +112 +y +. +beg +(); + g + !y. +d +(); it++) { + +115 i( +isSgVRefExp +( + +)) { + +116 i( +rcmp +( + +117 +isSgVRefExp +( + +)-> +g_symb +()-> +g_me +(). +gSg +(). +c_r +(), + +118 +vs +-> +g_me +(). +gSg +(). +c_r +())) { + +120 (* + g +)-> +t_symb +( + +121 +isSgVRefExp +( + +)-> +g_symb +()); + +127 } i( +isSgExessi +( + +)) { + +129 i( +isSgByOp +((* + +)-> +g_ +())) + +130 +isSgByOp +((* + +)-> +g_ +())-> +a_exessi +( + +131 * + +, + +); + +143 +de + + g +; + +144 + gfuncLi +[ +i +] = +NULL +; + +146 i( + gfuncLi +[ +i +] ! +NULL +) + +147 +throw + +_r +("not freedroperly"); + +151  +w + +CG_roRr +( +li +); + +154 + gl + = +ic_ +< +CG_roRr + *>( +mt +)-> +l_ +; + +157 i( + gl + = +NULL +) + +158 +throw + +_r +("bothistndnlreull!!"); + +160 +de + + gmt +; + +161  + gj +; + +162  + gn__symb_ +; + +163  + gi + = 1; i < +funcLi +. +size +(); i++) { + +164 + gn__symb_ + = 0; + +166 i(( + gfuncLi +[ +i +] = +NULL +&& (< +funcLi +. +size +())) + +168 i(( + gfuncLi +[ +i +] = +NULL +&& (= +funcLi +. +size +())) + +171 +CG_roRr + * + g + = +ic_ +( +funcLi +[ +i +]); + +172 +SgExessi +* + g + = + +-> +_ +; + +173 +de + + g +; + +174 + gfuncLi +[ +i +] = +NULL +; + +176 +SgVbSymb + * + gvs + = +symb_ +-> +fd_vb +( + +177 +SgName +( +lo_vs +[ +i +]. +c_r +())); + +179 i( + gvs + = +NULL +) { + +181 +n__symb_ + = 1; + +183 + gvs + = +symb2_ +-> +fd_vb +( +SgName +( +lo_vs +[ +i +]. +c_r +())); + +185 i( + gvs + ! +NULL +) { + +188 +d +:: +ve +< +SgVRefExp + *> +y + = +subu +( +l +, +vs +, + +, + +189 +ro_ +); + +191 i( + gn__symb_ + && +isSgVRefExp +( + +)) { + +192 i( +rcmp +( + +193 +isSgVRefExp +( + +)-> +g_symb +()-> +g_me +(). +gSg +(). +c_r +(), + +194 +vs +-> +g_me +(). +gSg +(). +c_r +())) { + +205  + gd +:: +ve +< +SgVRefExp + *>:: + + +j + = +y +. +beg +(); + +206 + gj + ! +y +. +d +(); j++) { + +209 i( +isSgVRefExp +( + +)) { + +210 i( +rcmp +( + +211 +isSgVRefExp +( + +)-> +g_symb +()-> +g_me +(). +gSg +(). +c_r +(), + +212 +vs +-> +g_me +(). +gSg +(). +c_r +())) { + +213 (* + gj +)-> +t_symb +( +isSgVRefExp +( + +)-> +g_symb +()); + +218 } i( +isSgExessi +( + +)) { + +220 i( +isSgByOp +((* +j +)-> +g_ +())) + +221 +isSgByOp +((* +j +)-> +g_ +())-> +a_exessi +( + +222 * +j +, + +); + +297  +w + +CG_roRr +( +l +); + +305 +CG_ouutRr +* + gCG_roBud +:: +CeAssignmt +(, CG_ouutR* +lhs +, + +306 +CG_ouutRr + * +rhs +) const { + +307 i( + glhs + = +NULL + || +rhs + == NULL) { + +308 +rtf +( +dr +, "Code generation: Missinghs orhs\n"); + +309  + gNULL +; + +312 +SgExessi +* + gc + = +ic_ +< +CG_roRr +*>( +rhs +)-> +_ +; + +313 +SgExessi +* + gd + = +ic_ +< +CG_roRr +*>( +lhs +)-> +_ +; + +315 +SgExSmt +* + gs + = +budAssignSmt +( +d +, +c +); + +316 + gc +-> +t_ +( +s +); + +317 + gd +-> +t_ +( +s +); + +319 +SgSmtPLi +* + gw_li + = +w + SgStatementPtrList; + +321 (* + gw_li +). +push_back +( +isSgSmt +( +s +)); + +323 +de + + glhs +; + +324 +de + + grhs +; + +326  +w + +CG_roRr +( +w_li +); + +333 +CG_ouutRr +* + gCG_roBud +:: +CeInvoke +(cڡ +d +:: +rg + & +ame +, + +334 +Tue +< +CG_ouutRr +*> & +li +) const { + +336 i( + game + = +d +:: +rg +("max"|| +ame + == std::string("min")) { + +337 i( +li +. +size +() == 0) { + +338  +NULL +; + +339 } i( + gli +. +size +() == 1) { + +340  +li +[1]; + +342  + gϡ + = +li +. +size +(); + +343 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +li +[ +ϡ +])-> +_ +; + +344 +de + + gli +[ +ϡ +]; + +345 + gli +. +de_ϡ +(); + +346 +CG_roRr + * + g + = +ic_ +( +CeInvoke +( +ame +, + +347 +li +)); + +348 +SgExessi +* + g1 + = + +-> +_ +; + +350 +SgExessi + * + gs +; + +351 +SgExLiExp +* + gg_li + = +budExLiExp +(); + +352 +ndExessi +( +g_li +, +1 +); + +353 +ndExessi +( +g_li +, +2 +); + +354 +SgVRefExp +* + gaque_v +; + +356 i( + game + = +d +:: +rg +("max")) { + +357 +aque_v + = +budOqueVRefExp +("__ro_gt", +glob_ +); + +358 + gs + = +isSgExessi +( + +359 +budFuniClExp +( +aque_v +, +g_li +)); + +362 + gaque_v + = +budOqueVRefExp +("__ro_", +glob_ +); + +363 + gs + = +isSgExessi +( + +364 +budFuniClExp +( +aque_v +, +g_li +)); + +366 + g +-> + g_ + = +s +; + +368  + g +; + +371 +rtf +( +dr +, + +373  + gNULL +; + +381 +CG_ouutRr +* + gCG_roBud +:: +CeCommt +(, + +382 cڡ +d +:: +rg + & +commtText +) const { + +383 i( +commtText + = +d +:: +rg +("")) { + +384  +NULL +; + +387 +SgLodNode + * + gl + = +w + SgLocatedNode(); + +388 +budCommt +( +l +, "//omega_commt: " + +commtText +); + +390  +w + +CG_roRr +( +isSgNode +( +l +)); + +397 +CG_ouutRr +* + gCG_roBud +:: +CeIf +(, CG_ouutR* +gudLi +, + +398 +CG_ouutRr + * +ue_mtLi +, CG_ouutR* +l_mtLi +) const { + +404 i( + gue_mtLi + = +NULL + && +l_mtLi + == NULL) { + +405 +de + +gudLi +; + +406  + gNULL +; + +407 } i( + ggudLi + = +NULL +) { + +408  +StmtLiAd +( +ue_mtLi +, +l_mtLi +); + +411 +SgExessi +* + ghd + = +ic_ +< +CG_roRr +*>( +gudLi +)-> +_ +; + +413 +SgSmtPLi + * + gth_1 +, * + g_1 +; + +414 +SgSmt +* + gth_ +; + +415 +SgSmt +* + g_ +; + +416 +SgBasicBlock +* + gth_2 +; + +417 +SgBasicBlock +* + g_2 +; + +418 i( + gue_mtLi + ! +NULL +) { + +419 +th_1 + = +ic_ +< +CG_roRr +*>( +ue_mtLi +)-> +li_ +; + +420 i( + gth_1 + ! +NULL +) { + +421 +th_ + = *((* +th_1 +). +beg +()); + +423 i((* + gth_1 +). +size +() > 1) { + +424 + gth_2 + = +budBasicBlock +(); + +425  + gSgSmtPLi +:: + + + + = (* +th_1 +). +beg +(); + +426 + g + !(* +th_1 +). +d +(); it++) { + +427 + gth_2 +-> +nd_emt +(* + +); + +430 + gth_ + = +isSgSmt +( +th_2 +); + +434 + gth_ + = +isSgSmt +( + +435 +ic_ +< +CG_roRr +*>( +ue_mtLi +)-> +l_ +); + +437 + gth_ + = +NULL +; + +439 i( + gl_mtLi + ! +NULL +) { + +440 +_1 + = +ic_ +< +CG_roRr +*>( +l_mtLi +)-> +li_ +; + +441 i( + g_1 + ! +NULL +) { + +442 +_ + = *((* +_1 +). +beg +()); + +443 i((* + g_1 +). +size +() > 1) { + +444 + g_2 + = +budBasicBlock +(); + +445  + gSgSmtPLi +:: + + +2 + = (* +_1 +). +beg +(); + +446 + g2 + !(* +_1 +). +d +(); it2++) { + +447 + g_2 +-> +nd_emt +(* +2 +); + +450 + g_ + = +isSgSmt +( +_2 +); + +454 + g_ + = +isSgSmt +( + +455 +ic_ +< +CG_roRr +*>( +l_mtLi +)-> +l_ +); + +457 + g_ + = +NULL +; + +460 +SgIfStmt +* + gti + = +budIfStmt +( +hd +, +isSgSmt +( +th_ +), + +461 +isSgSmt +( +_ +)); + +468 +de + + ggudLi +; + +469 +de + + gue_mtLi +; + +470 +de + + gl_mtLi +; + +472  +w + +CG_roRr +( +isSgNode +( +ti +)); + +479 +CG_ouutRr +* + gCG_roBud +:: +CeInduive +(CG_ouutR* +dex +, + +480 +CG_ouutRr + * +low +, CG_ouutR* +u +, CG_ouutR* + +) const { + +482 i( + gdex + = +NULL + || +low + =NULL || +u + == NULL) { + +483 +rtf +( +dr +, + +485  + gNULL +; + +488 i( + g + = +NULL +) + +489 + + = +w + +CG_roRr +( +isSgExessi +( +budIV +(1))); + +491 +SgVRefExp + * + gdex_sym + = +isSgVRefExp +( + +492 +ic_ +< +CG_roRr +*>( +dex +)-> +_ +); + +493 +SgExessi +* + glow_bound + = +ic_ +< +CG_roRr +*>( +low +)-> +_ +; + +494 +SgExessi +* + gu_bound + = +ic_ +< +CG_roRr +*>( +u +)-> +_ +; + +495 +SgExessi +* + g_size + = +ic_ +< +CG_roRr +*>( + +)-> +_ +; + +501 +SgSmt +* + gf__mt + = +budAssignSmt +( +dex_sym +, +low_bound +); + +502 +SgLessOrEquOp +* + gcd + = +budLessOrEquOp +( +dex_sym +, +u_bound +); + +503 +SgExSmt +* + g + = +budExSmt +( +cd +); + +504 +SgPlusAssignOp +* + gemt + = +budPlusAssignOp +( +dex_sym +, +_size +); + +505 +SgFSmt + * + gf_mt + = +budFSmt +( +f__mt +, + +506 +isSgSmt +( + +), +emt +, +NULL +); + +508 +de + + gdex +; + +509 +de + + glow +; + +510 +de + + gu +; + +511 +de + + g +; + +513  +w + +CG_roRr +( +isSgNode +( +f_mt +)); + +520 +CG_ouutRr +* + gCG_roBud +:: +CeAribu +(CG_ouutR* +cڌ +, + +521 cڡ +d +:: +rg + & +commtText +) const { + +523 +SgNode + * +l + = +ic_ +< +CG_roRr +*>( +cڌ +)-> +l_ +; + +525 + gl +-> +tAribu +("omega_commt", +w + +ATextAribu +( +commtText +)); + +527  + gic_ +< + gCG_roRr +*>( + gcڌ +); + +534 +CG_ouutRr +* + gCG_roBud +:: +CeLo +(, CG_ouutR* +cڌ +, + +535 +CG_ouutRr + * +mtLi +) const { + +536 i( + gmtLi + = +NULL +) { + +537 +de + +cڌ +; + +538  + gNULL +; + +539 } i( + gcڌ + = +NULL +) { + +540 +rtf +( +dr +, "Code generation:o inductive forhisoop\n"); + +541  + gmtLi +; + +544 +SgNode + * + gl + = +ic_ +< +CG_roRr +*>( +cڌ +)-> +l_ +; + +545 +SgFSmt + * + gtf + = +isSgFSmt +( +l +); + +547 +SgSmtPLi + * + gbody + = +ic_ +< +CG_roRr +*>( +mtLi +)-> +li_ +; + +549 i( + gbody + ! +NULL +) { + +550 i(!((* +body +). +emy +())) { + +551 i((* +body +). +size +() == 1) { + +553 +tf +-> +t_lo_body +(*((* +body +). +beg +())); + +554 (*((* + gbody +). +beg +()))-> +t_ +( +tf +); + +564 +SgBasicBlock +* + gbb + = +budBasicBlock +(); + +565 + gbb +-> +t_ +( +tf +); + +566  + gSgSmtPLi +:: + + + + = (* +body +). +beg +(); + +567 + g + !(* +body +). +d +(); it++) { + +568 + gbb +-> +nd_emt +(* + +); + +569 (* + g +)-> +t_ +( +bb +); + +571 + gtf +-> +t_lo_body +( +bb +); + +576 +SgNode +* + gl2 + = +ic_ +< +CG_roRr +*>( +mtLi +)-> +l_ +; + +578 i( + gl2 + ! +NULL +) { + +579 +tf +-> +t_lo_body +( +isSgSmt +( +l2 +)); + +580 + gl2 +-> +t_ +( +tf +); + +584 +de + + gmtLi +; + +586  + gcڌ +; + +592 +CG_ouutRr +* + gCG_roBud +:: +CeI +( +_i +) const { + +593  +w + +CG_roRr +( +isSgExessi +( +budIV +( +_i +))); + +596 +CG_ouutRr +* + gCG_roBud +:: +CeIdt +(cڡ +d +:: +rg + & +_s +) const { + +598 +SgVbSymb + * +vs + = +symb_ +-> +fd_vb +( +SgName +( +_s +. +c_r +())); + +599 +SgVbSymb + * + gvs2 + = +symb2_ +-> +fd_vb +( +SgName +( +_s +. +c_r +())); + +601 i( + gvs + = +NULL + && +vs2 + == NULL) { + +603 +SgVbDei +* +de + = +budVbDei +( + +604 +SgName +( +_s +. +c_r +()), +budITy +()); + +605 + gSgInlizedNamePLi +& + gvbs + = +de +-> +g_vbs +(); + +606 + gSgInlizedNamePLi +:: +cڡ_ + +i + = +vbs +. +beg +(); + +607 +SgInlizedName +* + glizedName + = * +i +; + +608 + gvs + = +w + +SgVbSymb +( +lizedName +); + +609 +dSmt +( +de +, +isSgSceSmt +( +ro_ +)); + +611 + gvs +-> +t_ +( +symb2_ +); + +612 + gsymb2_ +-> + +( +SgName +( +_s +. +c_r +()), +vs +); + +613  +w + +CG_roRr +( +isSgExessi +( +budVRefExp +( +vs +))); + +619 i(! +isSgExessi +( +budVRefExp +( +SgName +( +_s +. +c_r +())))) + +620 +throw + +_r +("error in Create ident!!"); + +621 i( + gvs2 + ! +NULL +) + +622  +w + +CG_roRr +( +isSgExessi +( +budVRefExp +( +vs2 +))); + +624  +w + +CG_roRr +( +isSgExessi +( +budVRefExp +( +vs +))); + +631 +CG_ouutRr +* + gCG_roBud +:: +CePlus +(CG_ouutR* +l +, + +632 +CG_ouutRr + * +r +) const { + +633 i( + gr + = +NULL +) { + +634  +l +; + +635 } i( + gl + = +NULL +) { + +636  +r +; + +639 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +640 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +642 +SgAddOp + * + gs + = +budAddOp +( +1 +, +2 +); + +643 + g1 +-> +t_ +( +s +); + +644 + g2 +-> +t_ +( +s +); + +645 +de + + gl +; + +646 +de + + gr +; + +648  +w + +CG_roRr +( +isSgExessi +( +s +)); + +652 +CG_ouutRr +* + gCG_roBud +:: +CeMus +(CG_ouutR* +l +, + +653 +CG_ouutRr + * +r +) const { + +654 i( + gr + = +NULL +) { + +655  +l +; + +656 } i( + gl + = +NULL +) { + +657 +SgExessi + * + + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +658 +SgMusOp + * + gs + = +budMusOp +( + +); + +660 +de + + gr +; + +662  +w + +CG_roRr +( +isSgExessi +( +s +)); + +664 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +665 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +667 +SgSubaOp + * + gs + = +budSubaOp +( +1 +, +2 +); + +668 + g1 +-> +t_ +( +s +); + +669 + g2 +-> +t_ +( +s +); + +670 +de + + gl +; + +671 +de + + gr +; + +672  +w + +CG_roRr +( +isSgExessi +( +s +)); + +677 +CG_ouutRr +* + gCG_roBud +:: +CeTimes +(CG_ouutR* +l +, + +678 +CG_ouutRr + * +r +) const { + +679 i( + gr + = +NULL + || +l + == NULL) { + +680 i( +r + ! +NULL +) { + +681 +r +-> +r +(); + +682 +de + + gr +; + +684 i( + gl + ! +NULL +) { + +685 +l +-> +r +(); + +686 +de + + gl +; + +688  + gNULL +; + +691 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +692 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +694 +SgMuɝlyOp + * + gs + = +budMuɝlyOp +( +1 +, +2 +); + +695 + g1 +-> +t_ +( +s +); + +696 + g2 +-> +t_ +( +s +); + +697 +de + + gl +; + +698 +de + + gr +; + +700  +w + +CG_roRr +( +isSgExessi +( +s +)); + +704 +CG_ouutRr +* + gCG_roBud +:: +CeIegDivide +(CG_ouutR* +l +, + +705 +CG_ouutRr + * +r +) const { + +706 i( + gr + = +NULL +) { + +707 +rtf +( +dr +, "Code generation: divide by NULL\n"); + +708  + gNULL +; + +709 } i( + gl + = +NULL +) { + +710 +de + +r +; + +711  + gNULL +; + +715 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +716 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +719 +SgDivideOp + * + gs + = +budDivideOp +( +1 +, +2 +); + +721 +de + + gl +; + +722 +de + + gr +; + +724  +w + +CG_roRr +( +isSgExessi +( +s +)); + +728 +CG_ouutRr +* + gCG_roBud +:: +CeIegMod +(CG_ouutR* +l +, + +729 +CG_ouutRr + * +r +) const { + +730 i( + gr + = +NULL + || +l + == NULL) { + +731  +NULL +; + +734 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +735 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +738 +SgModOp + * + gs + = +budModOp +( +1 +, +2 +); + +740 +de + + gl +; + +741 +de + + gr +; + +743  +w + +CG_roRr +( +isSgExessi +( +s +)); + +750 +CG_ouutRr +* + gCG_roBud +:: +CeAnd +(CG_ouutR* +l +, + +751 +CG_ouutRr + * +r +) const { + +752 i( + gr + = +NULL + || +l + == NULL) { + +753  +NULL +; + +756 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +757 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +759 +SgAndOp + * + gs + = +budAndOp +( +1 +, +2 +); + +761 +de + + gl +; + +762 +de + + gr +; + +764  +w + +CG_roRr +( +isSgExessi +( +s +)); + +771 +CG_ouutRr +* + gCG_roBud +:: +CeGE +(CG_ouutR* +l +, + +772 +CG_ouutRr + * +r +) const { + +773  +CeLE +( +r +, +l +); + +776 +CG_ouutRr +* + gCG_roBud +:: +CeLE +(CG_ouutR* +l +, + +777 +CG_ouutRr + * +r +) const { + +778 i( + gr + = +NULL + || +l + == NULL) { + +779  +NULL +; + +782 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +783 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +785 +SgLessOrEquOp + * + gs + = +budLessOrEquOp +( +1 +, +2 +); + +787 +de + + gl +; + +788 +de + + gr +; + +790  +w + +CG_roRr +( +isSgExessi +( +s +)); + +794 +CG_ouutRr +* + gCG_roBud +:: +CeEQ +(CG_ouutR* +l +, + +795 +CG_ouutRr + * +r +) const { + +796 i( + gr + = +NULL + || +l + == NULL) { + +797  +NULL +; + +800 +SgExessi +* + g1 + = +ic_ +< +CG_roRr +*>( +l +)-> +_ +; + +801 +SgExessi +* + g2 + = +ic_ +< +CG_roRr +*>( +r +)-> +_ +; + +803 +SgEquyOp + * + gs + = +budEquyOp +( +1 +, +2 +); + +805 +de + + gl +; + +806 +de + + gr +; + +808  +w + +CG_roRr +( +isSgExessi +( +s +)); + +815 +CG_ouutRr +* + gCG_roBud +:: +CeStmtLi +(CG_ouutR* +sgt +) const { + +819 i( +sgt + = +NULL +) { + +820  +w + +CG_roRr +ew +SgSmtPLi +); + +823 +SgSmtPLi + * + gl + = +ic_ +< +CG_roRr + *>( +sgt +)-> +li_ +; + +824 +SgNode +* + gsgn + = +ic_ +< +CG_roRr + *>( +sgt +)-> +l_ +; + +826 i( + gl + = +NULL +) + +827 +l + = +w + +SgSmtPLi +; + +829 i( + gsgn + = +NULL +) { + +830 +SgExessi +* + + = +ic_ +< +CG_roRr + *>( +sgt +)-> +_ +; + +832 i( + g + ! +NULL +) + +833 (* +l +). +push_back +( + +834 +budExSmt +( + +835 +ic_ +< +CG_roRr + *>( +sgt +)-> +_ +)); + +838 (* + gl +). +push_back +( +isSgSmt +( +sgn +)); + +840 +de + + gsgt +; + +841  +w + +CG_roRr +( +l +); + +850 +CG_ouutRr +* + gCG_roBud +:: +StmtLiInLa +(CG_ouutR* +li +, + +851 +CG_ouutRr + * +node +) const { + +852  +StmtLiAd +( +li +, +node +); + +855 +CG_ouutRr +* + gCG_roBud +:: +StmtLiAd +(CG_ouutR* +li1 +, + +856 +CG_ouutRr + * +li2 +) const { + +858 i( + gli2 + = +NULL +) { + +859  +li1 +; + +860 } i( + gli1 + = +NULL +) { + +861  +li2 +; + +868 +SgSmtPLi +* + gw_li +; + +870 +SgSmtPLi +* + gl1 + = +ic_ +< +CG_roRr + *>( +li1 +)-> +li_ +; + +871 +SgSmtPLi +* + gl2 + = +ic_ +< +CG_roRr + *>( +li2 +)-> +li_ +; + +872 +SgNode +* + ge + = +ic_ +< +CG_roRr + *>( +li1 +)-> +l_ +; + +873 +SgNode +* + gtwo + = +ic_ +< +CG_roRr + *>( +li2 +)-> +l_ +; + +875 +SgExessi +* + gexp1 + = +ic_ +< +CG_roRr + *>( +li1 +)-> +_ +; + +876 +SgExessi +* + gexp2 + = +ic_ +< +CG_roRr + *>( +li2 +)-> +_ +; + +878 i( + gexp1 + || + gexp2 +) + +879 +throw + +_r +("error in stmtlistappend!!"); + +895 i(( + gl1 + = +NULL +&& ( +l2 + == NULL)) { + +897 i(( +e + ! +NULL +&& ( +two + != NULL)) { + +899 +w_li + = +w + +SgSmtPLi +; + +901 (* + gw_li +). +push_back +( +isSgSmt +( +e +)); + +902 (* + gw_li +). +push_back +( +isSgSmt +( +two +)); + +904 +CG_roRr +* + gw_p + = +w + CG_roRr( +w_li +); + +906  + gic_ +< + gCG_ouutRr + *>( + gw_p +); + +908 } i(( + ge + ! +NULL +&& ( +two + == NULL)) { + +910  +ic_ +< +CG_ouutRr + *>( +w + +CG_roRr +( +e +)); + +912 } i(( + gtwo + ! +NULL +&& ( +e + == NULL)) { + +913  +ic_ +< +CG_ouutRr + *>( +w + +CG_roRr +( +two +)); + +918 i(( + gl2 + ! +NULL +&& ( +l1 + == NULL)) { + +925 i( +e + = +NULL +) + +926  +li2 +; + +929 (* + gl2 +). +push_back +( +isSgSmt +( +e +)); + +931  + gic_ +< + gCG_ouutRr + *>( +w + +CG_roRr +( +l2 +)); + +933 } i(( + gl1 + ! +NULL +&& ( +l2 + == NULL)) { + +934 i( +two + = +NULL +) + +935  +li1 +; + +938 (* + gl1 +). +push_back +( +isSgSmt +( +two +)); + +940  + gic_ +< + gCG_ouutRr + *>( +w + +CG_roRr +( +l1 +)); + +944 } i(( + gl1 + ! +NULL +&& ( +l2 + != NULL)) { + +946  +SgSmtPLi +:: + + + + = (* +l2 +). +beg +(); + +947 + g + !(* +l2 +). +d +(); it++) { + +948 (* + gl1 +). +push_back +(* + +); + +954  + gic_ +< + gCG_ouutRr + *>( +w + +CG_roRr +( +l1 +)); + +1002 +CG_ouutRr +* + gCG_roBud +:: +CeDim3 +(cڡ * +vName +,  +g1 +, + +1003  +g2 +) const { + +1005 +SgName + +ty_me +("dim3"); + +1006 +SgCssSymb + * + gty_symb + = +glob_sce +-> +lookup_ass_symb +( +ty_me +); + +1007 +SgCssDei + * + gty_de + = +isSgCssDei +( + +1008 +ty_symb +-> +g_dei +()); + +1012 +SgFuniSymb + * + g_symb + = +glob_sce +-> +lookup_funi_symb +( + +1013 +SgName +("dim3")); + +1015 +SgExLiExp + * + g_gs + = +budExLiExp +( +budIV +( +g1 +), + +1016 +budIV +( +g2 +)); + +1018 +SgFuniClExp + * + gdim3_func_ + = +budFuniClExp +( + +1019 +budFuniRefExp +( +_symb +-> +g_dei +()), +_gs +); + +1021  + gjoed_r +[20]; + +1023 +ry +( +joed_r +, "dim3 "); + +1024 +rt +( +joed_r +, +vName +); + +1026 +SgExSmt +* + gde + = +budAssignSmt +( + +1027 +budOqueVRefExp +( +joed_r +, +isSgSceSmt +( +ro_ +)), + +1028 +dim3_func_ +); + +1030 +SgSmtPLi + * + gl2 + = +w + SgStatementPtrList; + +1033 (* + gl2 +). +push_back +( +de +); + +1034  +w + +CG_roRr +( +l2 +); + +1037 +CG_ouutRr +* + gCG_roBud +:: +CeDim3 +(cڡ * +vName +,  +g1 +, + +1038  +g2 +,  +g3 +) const { + +1040 +SgName + +ty_me +("dim3"); + +1041 +SgCssSymb + * + gty_symb + = +glob_sce +-> +lookup_ass_symb +( +ty_me +); + +1042 +SgCssDei + * + gty_de + = +isSgCssDei +( + +1043 +ty_symb +-> +g_dei +()); + +1047 +SgFuniSymb + * + g_symb + = +glob_sce +-> +lookup_funi_symb +( + +1048 +SgName +("dim3")); + +1050 +SgExLiExp + * + g_gs + = +budExLiExp +( +budIV +( +g1 +), + +1051 +budIV +( +g2 +), budIV( +g3 +)); + +1053 +SgFuniClExp + * + gdim3_func_ + = +budFuniClExp +( + +1054 +budFuniRefExp +( +_symb +-> +g_dei +()), +_gs +); + +1056  + gjoed_r +[20]; + +1058 +ry +( +joed_r +, "dim3 "); + +1059 +rt +( +joed_r +, +vName +); + +1061 +SgExSmt +* + gde + = +budAssignSmt +( + +1062 +budOqueVRefExp +( +joed_r +, +isSgSceSmt +( +ro_ +)), + +1063 +dim3_func_ +); + +1065 +SgSmtPLi + * + gl2 + = +w + SgStatementPtrList; + +1068 (* + gl2 +). +push_back +( +de +); + +1069  +w + +CG_roRr +( +l2 +); + +1144 + gd +:: +ve +< +SgVRefExp + *> +subu +( +SgNode + * + +, cڡ +SgVbSymb + * +sym +, + +1145 +SgExessi +* +ex +, +SgNode +* +ro +) { + +1147 +SgSmt +* + gmt +; + +1148 +SgExessi +* + g +; + +1149 + gd +:: +ve +< +SgVRefExp + *> +ys +; + +1151 i( + g + ! +NULL +) { + +1152 i( +mt + = +isSgSmt +( + +)) { + +1153 i( +isSgBasicBlock +( +mt +)) { + +1154 +SgSmtPLi +& +mts + = + +1155 +isSgBasicBlock +( +mt +)-> +g_emts +(); + +1156  + gi + = 0; i < + gmts +. +size +(); i++) { + +1157 + gmts +[ +i +]-> +t_ +( +mt +); + +1158 + gd +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1159 +isSgNode +( +mts +[ +i +]), +sym +, +ex +, +ro +); + +1160 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1162 } i( +isSgFSmt +( +mt +)) { + +1163 +SgFSmt + * + gf + = +isSgFSmt +( +mt +); + +1164 + gf +-> +g_f__mt +()-> +t_ +( +f +); + +1165 + gf +-> +g_ +()-> +t_ +( +f +); + +1166 + gf +-> +g_emt +()-> +t_ +( +f +); + +1167 + gf +-> +g_lo_body +()-> +t_ +( +f +); + +1168 + gd +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1169 +isSgNode +( +f +-> +g_f__mt +()), +sym +, +ex +, +ro +); + +1170 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1171 + gd +:: +ve +< +SgVRefExp + *> +a1 + = +subu +( + +1172 +isSgNode +( +f +-> +g_ +()), +sym +, +ex +, +ro +); + +1173 + gd +:: +cy +( +a1 +. +beg +(),1. +d +(), +back_ +( +ys +)); + +1174 + gd +:: +ve +< +SgVRefExp + *> +a2 + = +subu +( + +1175 +isSgNode +( +f +-> +g_emt +()), +sym +, +ex +, +ro +); + +1176 + gd +:: +cy +( +a2 +. +beg +(),2. +d +(), +back_ +( +ys +)); + +1177 + gd +:: +ve +< +SgVRefExp + *> +a3 + = +subu +( + +1178 +isSgNode +( +f +-> +g_lo_body +()), +sym +, +ex +, +ro +); + +1179 + gd +:: +cy +( +a3 +. +beg +(),3. +d +(), +back_ +( +ys +)); + +1188 i( +isSgVbDei +( +mt +)) { + +1189 i( +SgExessi + * + g + = + +1190 +isSgVbDei +( +mt +)-> +g_vbs +(). +t +()-> +g_liz +()) { + +1191 i( +isSgAssignInliz +( + +)) { + +1192 +d +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1193 +isSgAssignInliz +( + +)-> +g_ݔd +(), +sym +, + +1194 +ex +, +ro +); + +1195 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1198 } i( +isSgIfStmt +( +mt +)) { + +1199 +SgIfStmt +* + gi + = +isSgIfStmt +( +mt +); + +1200 + gi +-> +g_cdiڮ +()-> +t_ +( +i +); + +1201 + gi +-> +g_ue_body +()-> +t_ +( +i +); + +1202 + gi +-> +g_l_body +()-> +t_ +( +i +); + +1203 + gd +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1204 +isSgNode +( +i +-> +g_cdiڮ +()), +sym +, +ex +, +ro +); + +1205 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1206 + gd +:: +ve +< +SgVRefExp + *> +a1 + = +subu +( + +1207 +isSgNode +( +i +-> +g_ue_body +()), +sym +, +ex +, +ro +); + +1208 + gd +:: +cy +( +a1 +. +beg +(),1. +d +(), +back_ +( +ys +)); + +1209 + gd +:: +ve +< +SgVRefExp + *> +a2 + = +subu +( + +1210 +isSgNode +( +i +-> +g_l_body +()), +sym +, +ex +, +ro +); + +1211 + gd +:: +cy +( +a2 +. +beg +(),2. +d +(), +back_ +( +ys +)); + +1212 } i( +isSgExSmt +( +mt +)) { + +1213 ( +isSgExSmt +( +mt +)-> +g_exessi +())-> +t_ +( + +1214 +isSgExSmt +( +mt +)); + +1215 + gd +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1216 +isSgNode +( +isSgExSmt +( +mt +)-> +g_exessi +()), + +1217 +sym +, +ex +, +ro +); + +1218 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1222 + g + = +isSgExessi +( + +); + +1224 + gd +:: +rg + +y + = +sym +-> +g_me +(). +gSg +(); + +1226 i( +isSgByOp +( + +)) { + +1228 +isSgByOp +( + +)-> +g_lhs_ݔd +()-> +t_ +(op); + +1229 +isSgByOp +( + +)-> +g_rhs_ݔd +()-> +t_ +(op); + +1231 + gd +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1232 +isSgByOp +( + +)-> +g_lhs_ݔd +(), +sym +, +ex +, +ro +); + +1233 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1234 + gd +:: +ve +< +SgVRefExp + *> +a1 + = +subu +( + +1235 +isSgByOp +( + +)-> +g_rhs_ݔd +(), +sym +, +ex +, +ro +); + +1236 + gd +:: +cy +( +a1 +. +beg +(),1. +d +(), +back_ +( +ys +)); + +1237 } i( +isSgUryOp +( + +)) { + +1238 +isSgUryOp +( + +)-> +g_ݔd +()-> +t_ +(op); + +1239 + gd +:: +ve +< +SgVRefExp + *> +a + = +subu +( + +1240 +isSgUryOp +( + +)-> +g_ݔd +(), +sym +, +ex +, +ro +); + +1241 + gd +:: +cy +( +a +. +beg +(),. +d +(), +back_ +( +ys +)); + +1242 } i( +isSgVRefExp +( + +)) { + +1243 + gd +:: +rg + +z + = + +1244 +isSgVRefExp +( + +)-> +g_symb +()-> +g_me +(). +gSg +(); + +1245 i(! +rcmp +( +z +. +c_r +(), +y +.c_str())) { + +1247 + gys +. +push_back +( +isSgVRefExp +( + +)); + +1273  + gys +; + + @CG_roseRepr.cc + +14  + ~ + +15  + ~ + +16  + ~ + +17  + ~ + +18 +mea + + gomega + { + +23 + gCG_roRr +:: +CG_roRr +(): +l_ +( +NULL +), +_ +(NULL), +li_ +(NULL){ + +27 + gCG_roRr +:: +CG_roRr +( +SgNode + * +l +): +l_ +), +_ +( +NULL +), +li_ +(NULL) { + +30 + gCG_roRr +:: +CG_roRr +( +SgExessi +* + +): +l_ +( +NULL +), +_ +(), +li_ +(NULL){ + +32 + gCG_roRr +:: +CG_roRr +( +SgSmtPLi +* +mi +): +l_ +( +NULL +), +_ +(NULL), +li_ +(stmtlist){ + +35 + gCG_roRr +::~ +CG_roRr +() { + +40 +CG_ouutRr +* +CG_roRr +:: +e +() { + +42 if +l_ + ! +NULL +) { + +43 +SgTeCy + +tc +; + +44 +SgNode + * + gl + = +l_ +-> +cy +( +tc +); + +45 + gl +-> +t_ +( +l_ +-> +g_ +()); + +46  +w + +CG_roRr +( +l +); + +48 if( + g_ + ! +NULL +) + +50 +SgTeCy + +tc1 +; + +51 +SgNode +* + g + = +isSgNode +( +_ +)-> +cy +( +tc1 +); + +53 + g +-> +t_ +( +isSgNode +( +_ +)-> +g_ +()); + +54  +w + +CG_roRr +( +isSgExessi +( + +)); + +56 if( + gli_ + ! +NULL +) + +58 +SgSmtPLi +* +li2 + = +w + SgStatementPtrList; + +60  + gSgSmtPLi +:: + + + + = (* +li_ +). +beg +(); + g + !(*li_). +d +(); it++){ + +61 +SgTeCy + + gtc3 +; + +62 +SgNode + * + gl2 + = +isSgNode +(* + +)-> +cy +( +tc3 +); + +63 + gl2 +-> +t_ +( +isSgNode +(* + +)-> +g_ +()); + +65 (* + gli2 +). +push_back +( +isSgSmt +( +l2 +)); + +67  +w + +CG_roRr +( +li2 +); + +70  + gNULL +; + +73  + gCG_roRr +:: +r +() { + +74 if( +l_ + ! +NULL +) { + +75 +de + +l_ +; + +76 + gl_ + = +NULL +; + +80 +SgNode +* + gCG_roRr +:: +GCode +() const { + +81  +l_ +; + +84 +SgSmtPLi +* + gCG_roRr +:: +GLi +() const { + +85  +li_ +; + +88 +SgExessi +* + gCG_roRr +:: +GExessi +() const { + +89  +_ +; + +91  + gCG_roRr +:: +Dump +() const { + +92 +SgNode +* +l + = +l_ +; + +93 +SgExessi +* + g + = +_ + ; + +94 if( + gl + ! +NULL +) + +95 +DumpFeHr +( +l +, +dout +); + +96 if( + g + ! +NULL +) + +97 +DumpFeHr +( +isSgNode +( + +), +dout +); + +101  + gCG_roRr +:: +DumpFeHr +( +SgNode +* +node +, +FILE + * + +) const{ + +102 + gd +:: +rg + +x +; + +103 +size_t + + gnumbOfSucsss + = +node +-> +g_numbOfTvlSucsss +(); + +104 if( + gnumbOfSucsss + == 0){ + +105 +x + = +node +-> +uŬToSg + (); + +106 +rtf +( + +, "%s", +x +. +c_r +()); + +109  +size_t + + gidx + = 0; idx < + gnumbOfSucsss +; idx++) + +111 +SgNode + * + gchd + = +NULL +; + +112 + gchd + = +node +-> +g_avlSucssByIndex +( +idx +); + +113 +DumpFeHr +( +chd +, + +); + +119  + gCG_roRr +:: +DumpToFe +( +FILE + * + +) const { + +121 +SgNode +* +l + = +l_ +; + +122 +SgExessi +* + g + = +_ + ; + +124 if( + gl +! +NULL +){ + +125 +d +:: +rg + +x + = +l +-> +uŬToSg +(); + +126 +rtf +( + +, "%s", +x +. +c_r +()); + +129 if( + g + ! +NULL +){ + +130 +d +:: +rg + +x + = +isSgNode +( + +)-> +uŬToSg +(); + +131 +rtf +( + +, "%s", +x +. +c_r +()); + + @CG_stringBuilder.cc + +17  + ~ + +18  + ~ + +19  + ~ + +21 +mea + + gomega + { + +23  + gd +:: +rg + +SagudSg +(cڡ +d +::rg & +s +,  + +); + +29 +CG_ouutRr +* + gCG_rgBud +:: +CePHd +( +dt +, + +30 +CG_ouutRr + * +mt +, +Tue + & +funcLi +, + +31 +Tue +< +d +:: +rg +> &) const { + +32 +d +:: +rg + +liS + = ""; + +34  + gi + = 1; i < +funcLi +. +size +(); i++) { + +35 i( + gfuncLi +[ +i +] = +NULL +) + +36 +liS + += "N/A"; + +38 + gliS + + +GSg +( +funcLi +[ +i +]); + +39 i( + gi + < + gfuncLi +. +size +()) + +40 + gliS + += ","; + +43 + gd +:: +rg + +mtName + = +GSg +( +mt +); + +44 + gd +:: +rg + +dtS + = +GIndtSs +( +dt +); + +46  +w + +CG_rgRr +( +dtS + + +mtName + + "(" + +liS + + ");\n"); + +49 +CG_ouutRr +* + gCG_rgBud +:: +CeAssignmt +( +dt +, + +50 +CG_ouutRr +* +lhs +, CG_ouutRr* +rhs +) const { + +51 i( + glhs + = +NULL + || +rhs + == NULL) { + +52 +rtf +( +dr +, "Code generation: missinghs orhs\n"); + +53  + gNULL +; + +56 + gd +:: +rg + +lhsS + = +GSg +( +lhs +); + +57 + gd +:: +rg + +rhsS + = +GSg +( +rhs +); + +59 + gd +:: +rg + +dtS + = +GIndtSs +( +dt +); + +61  +w + +CG_rgRr +( +dtS + + +lhsS + + "=" + +rhsS + + ";\n"); + +64 +CG_ouutRr +* + gCG_rgBud +:: +CeInvoke +(cڡ +d +:: +rg + & +ame +, + +65 +Tue +< +CG_ouutRr +*> & +li +) const { + +66 + gd +:: +rg + +liS + = ""; + +68  + gi + = 1; i < +li +. +size +(); i++) { + +69 + gliS + + +GSg +( +li +[ +i +]); + +70 i( + gi + < + gli +. +size +()) + +71 + gliS + += ","; + +74  +w + +CG_rgRr +( +ame + + "(" + +liS + + ")"); + +77 +CG_ouutRr +* + gCG_rgBud +:: +CeCommt +( +dt +, + +78 cڡ +d +:: +rg + & +commtText +) const { + +79 i( +commtText + = +d +:: +rg +("")) { + +80  +NULL +; + +83 + gd +:: +rg + +dtS + = +GIndtSs +( +dt +); + +85  +w + +CG_rgRr +( +dtS + + "// " + +commtText + + "\n"); + +88 +CG_ouutRr +* + gCG_rgBud +:: +CeAribu +(CG_ouutR* +cڌ +, + +89 cڡ +d +:: +rg + & +commtText +) const { + +90 i( +commtText + = +d +:: +rg +("")) { + +91  +cڌ +; + +94 + gd +:: +rg + +cڌSg + = +GSg +( +cڌ +); + +96  +w + +CG_rgRr +("// " + +commtText + + "\n" + +cڌSg +); + +100 +CG_ouutRr +* + gCG_rgBud +:: +CeIf +( +dt +, CG_ouutRr* +gudLi +, + +101 +CG_ouutRr +* +ue_mtLi +, CG_ouutRr* +l_mtLi +) const { + +102 i( + gue_mtLi + = +NULL + && +l_mtLi + == NULL) { + +103 +de + +gudLi +; + +104  + gNULL +; + +105 } i( + ggudLi + = +NULL +) { + +106  +StmtLiAd +( +ue_mtLi +, +l_mtLi +); + +109 + gd +:: +rg + +gudLiS + = +GSg +( +gudLi +); + +110 + gd +:: +rg + +dtS + = +GIndtSs +( +dt +); + +111 + gd +:: +rg + +s +; + +112 i( + gue_mtLi + ! +NULL + && +l_mtLi + == NULL) { + +113 +s + = +dtS + + "i(" + +gudLiS + + ") {\n" + +114 + +GSg +( +ue_mtLi ++ +dtS + + "}\n"; + +115 } i( + gue_mtLi + = +NULL + && +l_mtLi + != NULL) { + +116 +s + = +dtS + + "i!(" + +gudLiS + + ") {\n" + +117 + +GSg +( +l_mtLi ++ +dtS + + "}\n"; + +119 + gs + = +dtS + + "i(" + +gudLiS + + ") {\n" + +120 + +GSg +( +ue_mtLi ++ +dtS + + "}\n" + indentStr + +121 + " {\n" + +GSg +( +l_mtLi ++ +dtS + + "}\n"; + +124  +w + +CG_rgRr +( +s +); + +127 +CG_ouutRr +* + gCG_rgBud +:: +CeInduive +(CG_ouutRr* +dex +, + +128 +CG_ouutRr +* +low +, CG_ouutRr* +u +, CG_ouutRr* + +) const { + +129 i( + gdex + = +NULL +) { + +130 +rtf +( +dr +, "Code generation: missingoop index\n"); + +131  + gNULL +; + +134 i( + glow + = +NULL + || +u + == NULL) { + +135 +rtf +( +dr +, "Code generation: missingoop bound\n"); + +138 + gd +:: +rg + +dexS + = +GSg +( +dex +); + +139 + gd +:: +rg + +lowS +, + guS +; + +140 i( + glow + ! +NULL +) + +141 +lowS + = +GSg +( +low +); + +143 + glowS + = +d +:: +rg +("-infinity"); + +144 i( + gu + ! +NULL +) + +145 +uS + = +GSg +( +u +); + +147 + guS + = +d +:: +rg +("+infinity"); + +149 + gd +:: +rg + +doS + = "f(" + +dexS + + " = " + +lowS + + "; " + indexStr + +150 + " <" + +uS + + "; " + +dexS +; + +152 i( + g + ! +NULL +) { + +153 +d +:: +rg + +S + = +GSg +( + +); + +154 + gdoS + +" +" + +S +; + +156 + gdoS + += "++"; + +159 + gdoS + += ")"; + +161  +w + +CG_rgRr +( +doS +); + +164 +CG_ouutRr +* + gCG_rgBud +:: +CeLo +( +dt +, CG_ouutRr* +cڌ +, + +165 +CG_ouutRr +* +mtLi +) const { + +166 i( + gmtLi + = +NULL +) { + +167 +de + +cڌ +; + +168  + gNULL +; + +169 } i( + gcڌ + = +NULL +) { + +170 +rtf +( +dr +, "Code generation:o inductive forhisoop\n"); + +171  + gmtLi +; + +174 + gd +:: +rg + +S + = +GSg +( +cڌ +); + +175 + gd +:: +rg + +mtS + = +GSg +( +mtLi +); + +177 + gd +:: +rg + +dtS + = +GIndtSs +( +dt +); + +179 + gd +:: +rg + +s + = +dtS + + +S + + " {\n" + +mtS + + indentStr + "}\n"; + +181  +w + +CG_rgRr +( +s +); + +184 +CG_ouutRr +* + gCG_rgBud +:: +CeI +( +_i +) const { + +185 +d +:: +rg + +_s + = +to_rg +( +_i +); + +186  +w + +CG_rgRr +( +_s +); + +189 +CG_ouutRr +* + gCG_rgBud +:: +CeIdt +(cڡ +d +:: +rg + & +_s +) const { + +190 i(& +_s + = +NULL + || _= +d +:: +rg +("")) { + +191  +NULL +; + +194  +w + +CG_rgRr +( +_s +); + +197 +CG_ouutRr +* + gCG_rgBud +:: +CePlus +(CG_ouutRr* +l +, + +198 +CG_ouutRr +* +r +) const { + +199 i( + gr + = +NULL +) { + +200  +l +; + +201 } i( + gl + = +NULL +) { + +202  +r +; + +205 + gd +:: +rg + +lS + = +GSg +( +l +); + +206 + gd +:: +rg + +rS + = +GSg +( +r +); + +208  +w + +CG_rgRr +( +lS + + "+" + +rS +); + +211 +CG_ouutRr +* + gCG_rgBud +:: +CeMus +(CG_ouutRr* +l +, + +212 +CG_ouutRr +* +r +) const { + +213 i( + gr + = +NULL +) { + +214  +l +; + +215 } i( + gl + = +NULL +) { + +216 +d +:: +rg + +rS + = +GSg +( +r +); + +217  +w + +CG_rgRr +("-" + +SagudSg +( +rS +, '-')); + +220 + gd +:: +rg + +lS + = +GSg +( +l +); + +221 + gd +:: +rg + +rS + = +GSg +( +r +); + +223  +w + +CG_rgRr +( +lS + + "-" + +SagudSg +( +rS +, '-')); + +226 +CG_ouutRr +* + gCG_rgBud +:: +CeTimes +(CG_ouutRr* +l +, + +227 +CG_ouutRr +* +r +) const { + +228 i( + gr + = +NULL + || +l + == NULL) { + +229 +de + +r +; + +230 +de + + gl +; + +231  + gNULL +; + +234 + gd +:: +rg + +lS + = +GSg +( +l +); + +235 + gd +:: +rg + +rS + = +GSg +( +r +); + +237  +w + +CG_rgRr +( + +238 +SagudSg +( +lS +, '*'+ "*" + SagudSg( +rS +, '*')); + +241 +CG_ouutRr +* + gCG_rgBud +:: +CeIegDivide +(CG_ouutRr* +l +, + +242 +CG_ouutRr +* +r +) const { + +243 i( + gr + = +NULL +) { + +244 +rtf +( +dr +, "Code generation: divide by NULL\n"); + +245  + gNULL +; + +246 } i( + gl + = +NULL +) { + +247 +de + +r +; + +248  + gNULL +; + +251 + gd +:: +rg + +lS + = +GSg +( +l +); + +252 + gd +:: +rg + +rS + = +GSg +( +r +); + +254  +w + +CG_rgRr +("tDiv(" + +lS + + "," + +rS + + ")"); + +257 +CG_ouutRr +* + gCG_rgBud +:: +CeIegMod +(CG_ouutRr* +l +, + +258 +CG_ouutRr +* +r +) const { + +259 i( + gr + = +NULL + || +l + == NULL) { + +260  +NULL +; + +263 + gd +:: +rg + +lS + = +GSg +( +l +); + +264 + gd +:: +rg + +rS + = +GSg +( +r +); + +266  +w + +CG_rgRr +("tMod(" + +lS + + "," + +rS + + ")"); + +269 +CG_ouutRr +* + gCG_rgBud +:: +CeIegCe +(CG_ouutRr* +l +, + +270 +CG_ouutRr +* +r +) const { + +271 i( + gr + = +NULL + || +l + == NULL) { + +272  +NULL +; + +275 + gd +:: +rg + +lS + = +GSg +( +l +); + +276 + gd +:: +rg + +rS + = +GSg +( +r +); + +278  +w + +CG_rgRr +("tCe(" + +lS + + "," + +rS + + ")"); + +281 +CG_ouutRr +* + gCG_rgBud +:: +CeAnd +(CG_ouutRr* +l +, + +282 +CG_ouutRr +* +r +) const { + +283 i( + gr + = +NULL +) + +284  +l +; + +285 i( + gl + = +NULL +) + +286  +r +; + +288 + gd +:: +rg + +lS + = +GSg +( +l +); + +289 + gd +:: +rg + +rS + = +GSg +( +r +); + +291  +w + +CG_rgRr +( +lS + + " && " + +rS +); + +294 +CG_ouutRr +* + gCG_rgBud +:: +CeGE +(CG_ouutRr* +l +, + +295 +CG_ouutRr +* +r +) const { + +296 i( + gr + = +NULL + || +l + == NULL) { + +297  +NULL +; + +300 + gd +:: +rg + +lS + = +GSg +( +l +); + +301 + gd +:: +rg + +rS + = +GSg +( +r +); + +303  +w + +CG_rgRr +( +lS + + " >" + +rS +); + +306 +CG_ouutRr +* + gCG_rgBud +:: +CeLE +(CG_ouutRr* +l +, + +307 +CG_ouutRr +* +r +) const { + +308 i( + gr + = +NULL + || +l + == NULL) { + +309  +NULL +; + +312 + gd +:: +rg + +lS + = +GSg +( +l +); + +313 + gd +:: +rg + +rS + = +GSg +( +r +); + +315  +w + +CG_rgRr +( +lS + + " <" + +rS +); + +318 +CG_ouutRr +* + gCG_rgBud +:: +CeEQ +(CG_ouutRr* +l +, + +319 +CG_ouutRr +* +r +) const { + +320 i( + gr + = +NULL + || +l + == NULL) { + +321  +NULL +; + +324 + gd +:: +rg + +lS + = +GSg +( +l +); + +325 + gd +:: +rg + +rS + = +GSg +( +r +); + +327  +w + +CG_rgRr +( +lS + + " =" + +rS +); + +330 +CG_ouutRr +* + gCG_rgBud +:: +StmtLiAd +(CG_ouutRr* +li1 +, + +331 +CG_ouutRr +* +li2 +) const { + +332 i( + gli2 + = +NULL +) { + +333  +li1 +; + +334 } i( + gli1 + = +NULL +) { + +335  +li2 +; + +338 + gd +:: +rg + +li1S + = +GSg +( +li1 +); + +339 + gd +:: +rg + +li2S + = +GSg +( +li2 +); + +341  +w + +CG_rgRr +( +li1S + + +li2S +); + +347 + gd +:: +rg + +GIndtSs +( +dt +) { + +348 +d +:: +rg + +dtS +; + +349  + gi + = 1; i < + gdt +; i++) { + +350 + gdtS + += " "; + +352  + gdtS +; + +359 + gd +:: +rg + +GSg +( +CG_ouutRr +* + +) { + +360 +d +:: +rg + +su + = +ic_ +< +CG_rgRr + *>( + +)-> +GSg +(); + +361 +de + + g +; + +362  + gsu +; + +365  + gd +:: +rg + +SagudSg +(cڡ +d +::rg & +s +,  + +) { + +366  + gn + = +s +. +ngth +(); + +367  + gn_v + = 0; + +368  + gnum_usmus + = 0; + +369  + gnum_mul + = 0; + +370  + gnum_div + = 0; + +371  + gi + = 0; i < + gn +; i++) + +372  + gs +[ +i +]) { + +374 +n_v +++; + +377 +n_v +--; + +381 i( +n_v + == 0) + +382 +num_usmus +++; + +385 i( +n_v + == 0) + +386 +num_mul +++; + +389 i( +n_v + == 0) + +390 +num_div +++; + +396 +bo + + ged_n + = +l +; + +397  + g +) { + +399 i( +num_usmus + > 0) + +400 +ed_n + = +ue +; + +403 i( +num_usmus + > 0 || +num_div + > 0) + +404 +ed_n + = +ue +; + +407 i( +num_usmus + > 0 || +num_div + > 0 || +num_mul + > 0) + +408 +ed_n + = +ue +; + +414 i( + ged_n +) + +415  "(" + + gs + + ")"; + +417  + gs +; + + @CG_stringRepr.cc + +16  + ~ + +17  + ~ + +19 +mea + + gomega + { + +21 + gCG_rgRr +:: +CG_rgRr +() { + +24 +CG_rgRr +::CG_rgRr(cڡ +d +:: +rg +& +_s +: +s +(_s) { + +27 +CG_rgRr +::~CG_stringRepr() { + +30 +CG_ouutRr +* +CG_rgRr +:: +e +() { + +31  +w + +CG_rgRr +( +s +); + +38 + gd +:: +rg + +CG_rgRr +:: +GSg +() const { + +39  +s +; + +46  + gCG_rgRr +:: +Dump +() const { + +47 +tf +("%s\n", +s +. +c_r +()); + +50  + gCG_rgRr +:: +DumpToFe +( +FILE + * + +) const { + +51 +rtf +( + +,"%s", +s +. +c_r +()); + + @CG_suifBuilder.cc + +15  + ~ + +16  + ~ + +17  + ~ + +18  + ~ + +20 +mea + + gomega + { + +25 * + gk_ocg_commt +; + +26 * + gk_s2c_agma +; + +27 * + gk_cuda_dim3 +; + +28 * + gk_cuda_kl +; + +29 * + gk_cuda_modifr +; + +30 * + gk_cuda_xtu_memy +; + +38 +Tue +< Tue<> > +smtNSLevs +; + +39 +Tue +< Tue< +d +:: +rg +> > +loIdxNames +; + +40 +d +:: +ve +< std:: + +<, std:: +rg +> > +syncs +; + +41  +checkLoLev +; + +42  +mtFLoCheck +; + +43  +uBoundFLev +; + +44  +lowBoundFLev +; + +45 +bo + +flInBounds +; + +48 cڡ * + glibcode_g_v_rg + = ""; + +49 cڡ * + glibcode_g_who_rg + = ""; + +50 cڡ * + glibcode_g_suif_rg + = ""; + +53  +_code_g +() { + +54  +bo + + gisIn + = +l +; + +55 if(! + gisIn +) + +57 + gisIn + = +ue +; + +58 +ANNOTE +( +k_ocg_commt +, "omega_commt", +TRUE +); + +59 +ANNOTE +( +k_s2c_agma +, "s2agma", +TRUE +); + +60 +ANNOTE +( +k_cuda_dim3 +, "cuddim3", +TRUE +); + +61 +ANNOTE +( +k_cuda_kl +, "cudkl", +TRUE +); + +62 +ANNOTE +( +k_cuda_modifr +, "cudmodifr", +TRUE +); + +67  +ex_code_g +() { + +75 + gCG_suifBud +:: +CG_suifBud +( +oc_symb + * +symb +) + +77 +symb_ + = +symb +; + +78 +_code_g +(); + +81 +CG_ouutRr +* + gCG_suifBud +:: +CePHd + (, CG_ouutR* +mt +, + +82 +Tue +< +CG_ouutRr +*> & +funcLi +, Tue< +d +:: +rg +> & +lo_vs +) const { + +83 +_node_li + * +l + = +ic_ +< +CG_suifRr + *>( +mt +)-> +l_ +; + +84 +de + + gmt +; + +86  + gi + = 1; i < +funcLi +. +size +(); i++) { + +87 i( + gfuncLi +[ +i +] = +NULL +) + +90 +CG_suifRr + * + g + = +ic_ +( +funcLi +[ +i +]); + +91 +ݔd + + g + = + +-> +_ +; + +92 +de + + g +; + +94 +v_sym + * + gvs + = +ic_ +( +symb_ +-> +lookup_sym +( +lo_vs +[ +i +]. +c_r +(), +SYM_VAR +)); + +96 +subu +( +l +, +vs +, + +, +symb_ +); + +98 i( + g +. +is_r +()) + +99 +de + + g +. +r +(); + +102  +w + +CG_suifRr +( +l +); + +106 +CG_ouutRr +* + gCG_suifBud +:: +CeAssignmt +(, CG_ouutR* +lhs +, + +107 +CG_ouutRr + * +rhs +) const { + +108 i + glhs + = +NULL + || +rhs + == NULL ) { + +109 +rtf +( +dr +, "Code generation: Missinghs orhs\n"); + +110  + gNULL +; + +113 +ݔd + + gc + = +ic_ +< +CG_suifRr +*>( +rhs +)-> +_ +; + +114 i( + gc +. +is_r +(&& src. +r +()-> +code +(= +io_y +) { + +115 +_y + * + + = +ic_ +<_y *>( +c +. +r +()); + +116 +rui + * + gs + = +w + +_r +( +io_lod +, + +-> +em_ty +(), +ݔd +(), ia); + +117 + gc + = +ݔd +( +s +); + +120 +rui + * + gs +; + +121 +ݔd + + gd + = +ic_ +< +CG_suifRr +*>( +lhs +)-> +_ +; + +122 i( + gd +. +is_r +(&& d. +r +()-> +code +(= +io_y +) { + +123 +_y + * + + = +ic_ +<_y *>( +d +. +r +()); + +124 + gs + = +w + +_r +( +io_r +, +ty_void +, +ݔd +(), ond( + +), +c +); + +127 + gs + = +w + +_r +( +io_y +, +c +. +ty +(), +d +, src); + +129 +de + + glhs +; + +130 +de + + grhs +; + +132 +_node_li + * + gl + = +w +ree_node_list; + +133 + gl +-> +nd +( +w + +_r +( +s +)); + +135  +w + +CG_suifRr +( +l +); + +139 +CG_ouutRr +* + gCG_suifBud +:: +CeInvoke +(cڡ +d +:: +rg + & +ame +, + +140 +Tue +< +CG_ouutRr +*> & +li +) const { + +141 i( + game + = +d +:: +rg +("max"|| +ame + == std::string("min")) { + +142 i( +li +. +size +() == 0) { + +143  +NULL +; + +145 i( + gli +. +size +() == 1) { + +146  +li +[1]; + +149  + gϡ + = +li +. +size +(); + +150 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +li +[ +ϡ +])-> +_ +; + +151 +de + + gli +[ +ϡ +]; + +152 + gli +. +de_ϡ +(); + +153 +CG_suifRr + * + g + = +ic_ +( +CeInvoke +( +ame +, +li +)); + +154 +ݔd + + g1 + = + +-> +_ +; + +156 +rui + * + gs +; + +157 i( + game + = +d +:: +rg +("max")) + +158 +s + = +w + +_r +( +io_max +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +160 + gs + = +w + +_r +( +io_m +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +162 + g +-> + g_ + = +ݔd +( +s +); + +164  + g +; + +168 +rtf +( +dr +, "Code generation: invoke function io_callot implemented\n"); + +169  + gNULL +; + +174 +CG_ouutRr +* + gCG_suifBud +:: +CeAribu +(CG_ouutR* +cڌ +, + +175 cڡ +d +:: +rg + & +commtText +)const { + +176 i( +commtText + = +d +:: +rg +("")) { + +177  +cڌ +; + +180 +rui + * + gs + = +w + +_r +( +io_mrk +); + +182 +immed_li + * + giml + = +w + immed_list; + +183 + giml +-> +nd +( +immed +( +cڡ_ +<*>( +commtText +. +c_r +()))); + +184 + gs +-> +d_ne +( +k_ocg_commt +, +iml +); + +186 +_node_li + * + gl + ; + +187 + gl + = +ic_ +< +CG_suifRr +*>( +cڌ +)-> +l_ +; + +188 + gl +-> +nd +( +w + +_r +( +s +)); + +191  +w + +CG_suifRr +( +l +); + +198 +CG_ouutRr +* + gCG_suifBud +:: +CeCommt +(, cڡ +d +:: +rg + & +commtText +) const { + +199 i +commtText + = +d +:: +rg +("") ) { + +200  +NULL +; + +203 +rui + * + gs + = +w + +_r +( +io_mrk +); + +205 +immed_li + * + giml + = +w + immed_list; + +206 + giml +-> +nd +( +immed +( +cڡ_ +<*>( +commtText +. +c_r +()))); + +207 + gs +-> +d_ne +( +k_ocg_commt +, +iml +); + +209 +_node_li + * + gl + = +w +ree_node_list; + +210 + gl +-> +nd +( +w + +_r +( +s +)); + +212  +w + +CG_suifRr +( +l +); + +216 +CG_ouutRr +* + gCG_suifBud +:: +CeIf +(, CG_ouutR* +gudLi +, + +217 +CG_ouutRr + * +ue_mtLi +, CG_ouutR* +l_mtLi +) const { + +218  + gif_cou + = 1; + +219 + gd +:: +rg + +s + = +d +::rg("omegaif_")+ +to_rg +( +if_cou +++); + +220 +b_sym + * + gif_b + = +w +ab_sym( +cڡ_ +<*>( +s +. +c_r +())); + +221 + gsymb_ +-> +add_sym +( +if_b +); + +223 i + gue_mtLi + = +NULL + && +l_mtLi + == NULL ) { + +224 +de + +gudLi +; + +225  + gNULL +; + +227 i + ggudLi + = +NULL + ) { + +228  +StmtLiAd +( +ue_mtLi +, +l_mtLi +); + +231 +_node_li + * + ghd + = +w +ree_node_list; + +232 +ݔd + + g + = +ic_ +< +CG_suifRr +*>( +gudLi +)-> +_ +; + +234 + gd +:: +ack +<*> +S +; + +235 + gS +. +push +( + +. +r +()); + +236 ! + gS +. +emy +()) { + +237 +rui + * + gs + = +ic_ +( +S +. +t +()); + +238 + gS +. +p +(); + +239 i( + gs +-> +code +(= +io_d +) { + +240 +rui + * +s1 + = +s +-> +c_ +(0). +r +(); + +241 + gs1 +-> +move +(); + +242 + gS +. +push +( +s1 +); + +243 +rui + * + gs2 + = +s +-> +c_ +(1). +r +(); + +244 + gs2 +-> +move +(); + +245 + gS +. +push +( +s2 +); + +246 +de + + gs +; + +249 + gs + = +w + +_bj +( +io_bl +, +if_b +, +ݔd +( +s +)); + +250 + ghd +-> +nd +( +w + +_r +( +s +)); + +254 +_node_li + * + gth_ +, * + g_ +; + +255 i( + gue_mtLi + ! +NULL +) + +256 +th_ + = +ic_ +< +CG_suifRr +*>( +ue_mtLi +)-> +l_ +; + +258 + gth_ + = +NULL +; + +259 i( + gl_mtLi + ! +NULL +) + +260 +_ + = +ic_ +< +CG_suifRr +*>( +l_mtLi +)-> +l_ +; + +262 + g_ + = +NULL +; + +263 +_if + * + gti + = +w +e_if( +if_b +, +hd +, +th_ +, +_ +); + +265 +_node_li + * + gl + = +w +ree_node_list; + +266 + gl +-> +nd +( +ti +); + +268 +de + + ggudLi +; + +269 +de + + gue_mtLi +; + +270 +de + + gl_mtLi +; + +272  +w + +CG_suifRr +( +l +); + +276 +CG_ouutRr +* + gCG_suifBud +:: +CeInduive +(CG_ouutR* +dex +, + +277 +CG_ouutRr + * +low +, + +278 +CG_ouutRr + * +u +, + +279 +CG_ouutRr + * + +) const { + +280 i + gdex + = +NULL + || +low + =NULL || +u + == NULL ) { + +281 +rtf +( +dr +, "Code generation: something wrong in CreateInductive\n"); + +282  + gNULL +; + +285 i( + g + = +NULL +) + +286 + + = +CeI +(1); + +288 +v_sym + * + gdex_sym + = +ic_ +< +CG_suifRr +*>( +dex +)-> +_ +. +symb +(); + +289 +ݔd + + glow_bound + = +ic_ +< +CG_suifRr +*>( +low +)-> +_ +; + +290 +ݔd + + gu_bound + = +ic_ +< +CG_suifRr +*>( +u +)-> +_ +; + +291 +ݔd + + g_size + = +ic_ +< +CG_suifRr +*>( + +)-> +_ +; + +293 +b_sym + * + gctLab + = +w +abel_sym(""); + +294 +b_sym + * + gbrkLab + = +w +abel_sym(""); + +295 + gsymb_ +-> +add_sym +( +ctLab +); + +296 + gsymb_ +-> +add_sym +( +brkLab +); + +297 +_f + * + gtf + = +w +e_f( +dex_sym +, +FOR_SLTE +, +ctLab +, +brkLab +, +NULL +, + +298 +low_bound +, +u_bound +, +_size +, +NULL +); + +300 +_node_li + * + gl + = +w +ree_node_list; + +301 + gl +-> +nd +( +tf +); + +303 +de + + gdex +; + +304 +de + + glow +; + +305 +de + + gu +; + +306 +de + + g +; + +308  +w + +CG_suifRr +( +l +); + +312 +CG_ouutRr +* + gCG_suifBud +:: +CeLo +(, CG_ouutR* +cڌ +, + +313 +CG_ouutRr + * +mtLi +) const { + +314 i + gmtLi + = +NULL + ) { + +315 +de + +cڌ +; + +316  + gNULL +; + +318 i + gcڌ + = +NULL + ) { + +319 +rtf +( +dr +, "Code generation:o inductive forhisoop\n"); + +320  + gmtLi +; + +323 +_node_li + * + gl + = +ic_ +< +CG_suifRr +*>( +cڌ +)-> +l_ +; + +324 +_node_li_ + + +( +l +); + +325 +_f + * + gtf + = +ic_ +<_f*>( + +. + +()); + +327 +_node_li + * + gbody + = +ic_ +< +CG_suifRr +*>( +mtLi +)-> +l_ +; + +328 + gtf +-> +t_body +( +body +); + +330 +de + + gmtLi +; + +332  + gcڌ +; + +336 +CG_ouutRr +* + gCG_suifBud +:: +CeI +( +_i +) const { + +337 +_ldc + * +s + = +w + in_ldc( +ty_s32 +, +ݔd +(), +immed +( +_i +)); + +339  +w + +CG_suifRr +( +ݔd +( +s +)); + +343 +CG_ouutRr +* + gCG_suifBud +:: +CeIdt +(cڡ +d +:: +rg + & +_s +) const { + +344 i& +_s + = +NULL + || _= +d +:: +rg +("") ) { + +345  +NULL +; + +348 +v_sym + * + gvs + = +ic_ +( +symb_ +-> +lookup_sym +( +_s +. +c_r +(), +SYM_VAR +)); + +350 i( + gvs + = +NULL +) { + +351 +vs + = +w + +v_sym +( +ty_s32 +, +cڡ_ +<*>( +_s +. +c_r +())); + +352 + gsymb_ +-> +add_sym +( +vs +); + +355  +w + +CG_suifRr +( +ݔd +( +vs +)); + +359 +CG_ouutRr +* + gCG_suifBud +:: +CePlus +(CG_ouutR* +l +, + +360 +CG_ouutRr + * +r +) const { + +361 i + gr + = +NULL + ) { + +362  +l +; + +364 i + gl + = +NULL + ) { + +365  +r +; + +368 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +369 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +371 +rui + * + gs + = +w + +_r +( +io_add +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +373 +de + + gl +; + +374 +de + + gr +; + +376  +w + +CG_suifRr +( +ݔd +( +s +)); + +380 +CG_ouutRr +* + gCG_suifBud +:: +CeMus +(CG_ouutR* +l +, + +381 +CG_ouutRr + * +r +) const { + +382 i + gr + = +NULL + ) { + +383  +l +; + +385 i + gl + = +NULL + ) { + +386 +ݔd + + + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +387 +rui + * + gs + = +w + +_r +( +io_g +, + +. +ty +(), +ݔd +(), op); + +389 +de + + gr +; + +391  +w + +CG_suifRr +( +ݔd +( +s +)); + +394 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +395 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +397 +rui + * + gs + = +w + +_r +( +io_sub +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +399 +de + + gl +; + +400 +de + + gr +; + +402  +w + +CG_suifRr +( +ݔd +( +s +)); + +407 +CG_ouutRr +* + gCG_suifBud +:: +CeTimes +(CG_ouutR* +l +, + +408 +CG_ouutRr + * +r +) const { + +409 i + gr + = +NULL + || +l + == NULL) { + +410 i( +r + ! +NULL +) { + +411 +r +-> +r +(); + +412 +de + + gr +; + +414 i( + gl + ! +NULL +) { + +415 +l +-> +r +(); + +416 +de + + gl +; + +418  + gNULL +; + +421 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +422 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +424 +rui + * + gs + = +w + +_r +( +io_mul +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +426 +de + + gl +; + +427 +de + + gr +; + +429  +w + +CG_suifRr +( +ݔd +( +s +)); + +433 +CG_ouutRr +* + gCG_suifBud +:: +CeIegDivide +(CG_ouutR* +l +, + +434 +CG_ouutRr + * +r +) const { + +435 i + gr + = +NULL + ) { + +436 +rtf +( +dr +, "Code generation: divide by NULL\n"); + +437  + gNULL +; + +439 i + gl + = +NULL + ) { + +440 +de + +r +; + +441  + gNULL +; + +445 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +446 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +449 +rui + * + gs + = +w + +_r +( +io_div +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +451 +de + + gl +; + +452 +de + + gr +; + +454  +w + +CG_suifRr +( +ݔd +( +s +)); + +458 +CG_ouutRr +* + gCG_suifBud +:: +CeIegMod +(CG_ouutR* +l +, + +459 +CG_ouutRr + * +r +) const { + +460 i + gr + = +NULL + || +l + == NULL ) { + +461  +NULL +; + +464 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +465 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +468 +rui + * + gs + = +w + +_r +( +io_m +, +ty_s32 +, +ݔd +(), +1 +, +2 +); + +470 +de + + gl +; + +471 +de + + gr +; + +473  +w + +CG_suifRr +( +ݔd +( +s +)); + +477 +CG_ouutRr +* + gCG_suifBud +:: +CeAnd +(CG_ouutR* +l +, + +478 +CG_ouutRr + * +r +) const { + +479 i( + gr + = +NULL +) + +480  +l +; + +481 i( + gl + = +NULL +) + +482  +r +; + +484 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +485 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +487 +rui + * + gs + = +w + +_r +( +io_d +, +1 +. +ty +(), +ݔd +(), op1, +2 +); + +489 +de + + gl +; + +490 +de + + gr +; + +492  +w + +CG_suifRr +( +ݔd +( +s +)); + +496 +CG_ouutRr +* + gCG_suifBud +:: +CeGE +(CG_ouutR* +l +, + +497 +CG_ouutRr + * +r +) const { + +498  +CeLE +( +r +, +l +); + +502 +CG_ouutRr +* + gCG_suifBud +:: +CeLE +(CG_ouutR* +l +, + +503 +CG_ouutRr + * +r +) const { + +504 i + gr + = +NULL + || +l + == NULL ) { + +505  +NULL +; + +508 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +509 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +511 +rui + * + gs + = +w + +_r +( +io_e +, +ty_s32 +, +ݔd +(), +1 +, +2 +); + +513 +de + + gl +; + +514 +de + + gr +; + +516  +w + +CG_suifRr +( +ݔd +( +s +)); + +520 +CG_ouutRr +* + gCG_suifBud +:: +CeEQ +(CG_ouutR* +l +, + +521 +CG_ouutRr + * +r +) const { + +522 i + gr + = +NULL + || +l + == NULL ) { + +523  +NULL +; + +526 +ݔd + + g1 + = +ic_ +< +CG_suifRr +*>( +l +)-> +_ +; + +527 +ݔd + + g2 + = +ic_ +< +CG_suifRr +*>( +r +)-> +_ +; + +529 +rui + * + gs + = +w + +_r +( +io_q +, +ty_s32 +, +ݔd +(), +1 +, +2 +); + +531 +de + + gl +; + +532 +de + + gr +; + +534  +w + +CG_suifRr +( +ݔd +( +s +)); + +539 +CG_ouutRr +* + gCG_suifBud +:: +StmtLiAd +(CG_ouutR* +li1 +, + +540 +CG_ouutRr + * +li2 +) const { + +541 i + gli2 + = +NULL + ) { + +542  +li1 +; + +544 i + gli1 + = +NULL + ) { + +545  +li2 +; + +548 +_node_li + * + gl1 + = +ic_ +< +CG_suifRr + *>( +li1 +)-> +l_ +; + +549 +_node_li + * + gl2 + = +ic_ +< +CG_suifRr + *>( +li2 +)-> +l_ +; + +550 i( + gl2 + = +NULL +) + +551 +l1 +-> +nd +( +w + +_r +( +ic_ +< +CG_suifRr + *>( +li2 +)-> +_ +. +r +())); + +553 + gl1 +-> +nd +( +l2 +); + +555 +de + + gli2 +; + +557  + gli1 +; + +565 +CG_ouutRr +* + gCG_suifBud +:: +CePgma +(, + +566 cڡ +d +:: +rg + & +agmaText +) const { + +567 i +agmaText + = +d +:: +rg +("") ) { + +568  +NULL +; + +570 +rui + * + gs + = +w + +_r +( +io_mrk +); + +571 +immed_li + * + giml + = +w + immed_list; + +572 + giml +-> +nd +( +immed +( +cڡ_ +<*>( +agmaText +. +c_r +()))); + +573 + gs +-> +nd_ne +( +k_s2c_agma +, +iml +); + +574 +_node_li + * + gl + = +w +ree_node_list; + +575 + gl +-> +nd +( +w + +_r +( +s +)); + +576  +w + +CG_suifRr +( +l +); + +579 +CG_ouutRr +* + gCG_suifBud +:: +CeDim3 +( +immed + +vName +, immed +g1 +, immed +g2 +) const { + +580 +rui + * + gs + = +w + +_r +( +io_mrk +); + +581 +immed_li + * + giml + = +w + immed_list; + +582 + giml +-> +nd +( +immed +( +vName +)); + +583 + giml +-> +nd +( +g1 +); + +584 + giml +-> +nd +( +g2 +); + +585 + gs +-> +nd_ne +( +k_cuda_dim3 +, +iml +); + +586 +_node_li + * + gl + = +w +ree_node_list; + +587 + gl +-> +nd +( +w + +_r +( +s +)); + +588  +w + +CG_suifRr +( +l +); + +591 +CG_ouutRr +* + gCG_suifBud +:: +CeDim3 +( +immed + +vName +, immed +g1 +, immed +g2 +, immed +g3 +) const { + +592 +rui + * + gs + = +w + +_r +( +io_mrk +); + +593 +immed_li + * + giml + = +w + immed_list; + +594 + giml +-> +nd +( +immed +( +vName +)); + +595 + giml +-> +nd +( +g1 +); + +596 + giml +-> +nd +( +g2 +); + +597 + giml +-> +nd +( +g3 +); + +598 + gs +-> +nd_ne +( +k_cuda_dim3 +, +iml +); + +599 +_node_li + * + gl + = +w +ree_node_list; + +600 + gl +-> +nd +( +w + +_r +( +s +)); + +601  +w + +CG_suifRr +( +l +); + +604 +CG_ouutRr +* + gCG_suifBud +:: +CeKl +( +immed_li +* +iml +) const { + +605 +rui + * +s + = +w + +_r +( +io_mrk +); + +606 + gs +-> +nd_ne +( +k_cuda_kl +, +iml +); + +607 +_node_li + * + gl + = +w +ree_node_list; + +608 + gl +-> +nd +( +w + +_r +( +s +)); + +609  +w + +CG_suifRr +( +l +); + +612 +ty_node +* + gCG_suifBud +:: +ModifyTy +y_node* +ba +, cڡ * +modifr +) const { + +613 +modifr_ty +* + gsu + = +w + modifr_ty( +TYPE_NULL +, +ba +); + +614 +immed_li + * + giml + = +w + immed_list; + +615 + giml +-> +nd +( +immed +((*) +modifr +)); + +616 + gsu +-> +nd_ne +( +k_cuda_modifr +, +iml +); + +617  + gsu +; + +626 +bo + +subu +( +rui + * + +, +v_sym + * +sym +, +ݔd + +ex +, +ba_symb + * + +) { + +627 i( + g + = +NULL + || +sym + == NULL) + +628  +l +; + +630 +bo + + gr + = +l +; + +631  + gi + = 0; i < + g +-> +num_cs +(); i++) { + +632 +ݔd + + +( + +-> +c_ +( +i +)); + +634 i( + g +. +is_symb +(&& op. +symb +(= +sym +) { + +635 + +-> +t_c_ +( +i +, +ex +. +e +( + +)); + +636 + gr + = +ue +; + +638 i( + g +. +is_r +()) { + +639 + gr + = +subu +( + +. +r +(), +sym +, +ex +, + +) ||; + +643  + gr +; + +646 +bo + +subu +( +_node + * + +, +v_sym + * +sym +, +ݔd + +ex +, +ba_symb + * + +) { + +647 i( + g + = +NULL +) + +648  +l +; + +650 +bo + + gr + = +l +; + +651 i( + g +-> +kd +(= +TREE_INSTR +) + +652 +r + = +subu +( +ic_ +< +_r +*>( + +)-> +r +(), +sym +, +ex +, + +|| + gr +; + +654  + gi + = 0; i < + g +-> +num_chd_lis +(); i++) { + +655 + gr + = +subu +( + +-> +chd_li_num +( +i +), +sym +, +ex +, + +) ||; + +659  + gr +; + +662 +bo + +subu +( +_node_li + * +l +, +v_sym + * +sym +, +ݔd + +ex +, + +663 +ba_symb + * + +) { + +664 i( + gl + = +NULL +) + +665  +l +; + +667 +bo + + gr + = +l +; + +668 +_node_li_ + + +( +l +); + +669 ! + g +. +is_emy +()) { + +670 +_node + * + g + = + +. + +(); + +672 + gr + = +subu +( + +, +sym +, +ex +, + +) ||; + +675  + gr +; + + @CG_suifRepr.cc + +14  + ~ + +15  + ~ + +17 +mea + + gomega + { + +19 + gCG_suifRr +:: +CG_suifRr +(): +l_ +( +NULL +), +_ +() { + +22 + gCG_suifRr +:: +CG_suifRr +( +_node_li + * +l +): +l_ +), +_ +() { + +25 + gCG_suifRr +:: +CG_suifRr +( +ݔd + + +): +l_ +( +NULL +), +_ +(op) { + +28 + gCG_suifRr +::~ +CG_suifRr +() { + +33 +CG_ouutRr +* +CG_suifRr +:: +e +() { + +34 i(! +_ +. +is_nu +() ) { + +35 +ݔd + + + = +_ +. +e +(); + +36  +w + +CG_suifRr +( + +); + +38 i( + gl_ + ! +NULL +) { + +39 +_node_li + * +l + = +l_ +-> +e +(); + +40  +w + +CG_suifRr +( +l +); + +43  +w + +CG_suifRr +(); + +46  + gCG_suifRr +:: +r +() { + +47 i(! +_ +. +is_nu +()) { + +48 i( +_ +. +is_r +()) + +49 +de + +_ +. +r +(); + +50 + g_ +. +t_nu +(); + +52 i( + gl_ + ! +NULL +) { + +53 +de + +l_ +; + +54 + gl_ + = +NULL +; + +58 +_node_li +* + gCG_suifRr +:: +GCode +() const { + +59  +l_ +; + +62 +ݔd + + gCG_suifRr +:: +GExessi +() const { + +63  +_ +; + +66  + gCG_suifRr +:: +Dump +() const { + +67 i( +l_ + ! +NULL +) + +68 +l_ +-> +t +(); + +69 i(! + g_ +. +is_nu +()) + +70 + g_ +. +t +(); + +73  + gCG_suifRr +:: +DumpToFe +( +FILE + * + +) const { + +74 i( +l_ + ! +NULL +) + +75 +l_ +-> +t +( + +); + +76 i(! + g_ +. +is_nu +()) + +77 + g_ +. +t +( + +); + + @code_gen.cc + +16  + ~ + +17  + ~ + +18  + ~ + +19  + ~ + +20  + ~ + +21  + ~ + +22  + ~ + +23  + ~ + +24  + ~ + +26  + ~ + +27  + ~ + +28  + ~ + +29  + ~ + +30  + ~ + +31  + ~ + +32  + ~ + +34 +mea + + gomega + { + +37  + gϡ_v +; + +38 +STue + + gw_IS +; + +39 +STueTue + + gojeed_nIS +; + +40 + gTue +< + gCG_ouutRr + *> + gemtInfo +; + +41 +RTue + + gsfmis +; + +44 + gTue +< Tue<> > + gsmtNSLevs +; + +45 + gTue +< Tue< + gd +:: +rg +> > +loIdxNames +; + +46 + gd +:: +ve +< +d +:: + +<, std:: +rg +> > +syncs +; + +51  + gcheckLoLev +; + +52  + gmtFLoCheck +; + +53  + guBoundFLev +; + +54  + glowBoundFLev +; + +55 +bo + + gflInBounds +; + +58 as + cJunkSticIn +{ + gpublic +: +JunkSticIn +(){ +checkLoLev +=0; + gflInBounds += +l +;} }; + +59  +JunkSticIn + + gjunkInIn__ +; + +64 +CG_su + * +g_cursive +( +v +, +ITue + & +isAive +); + +67  + gcode_g_debug +=0; + +70 +STue + + $fr_funi_symbs +( +STue + & +ts +, +bo + +kp_fs +){ + +71 +STue + + `w_ts +( +ts +. + `size +()); + +72  +i + = 1; i < +ts +. + `size +(); i++) { + +73 +Ri + +R + = +ts +[ +i +]; + +74 +Ri + & +S + = +w_ts +[ +i +]; + +75 + `as +( +R +. + `is_t +()); + +77 +S + = + `Ri +( +R +. + `n_t +()); + +78 +S +. + `cy_mes +( +R +); + +79 +F_Exis + * + + = +S +. + `add_exis +(); + +80 +F_Or + * +fo + = + +-> + `add_ +(); + +81  +DNF_It + + `D +( +R +. + `quy_DNF +()); +D +; D++) { + +82 +F_And + * + + = +fo +-> + `add_d +(); + +83 +Vb_ID_Tue + & +dlols + = (* +D +)-> + `lols +(); + +84 +Sei +< +Vb_ID +> +wlols + = + +-> + `dee_tue +( +dlols +. + `size +()); + +91  +EQ_It + + `e +(* +D +); +e +;++) + +92 if(( + `max_fs_y +(* +e +> 0= +kp_fs +){ + +93 +EQ_Hd + +n + = + +-> + `add_EQ +(); + +94  +Cڡr_Vs_Ir + + `cvi +(* +e +, +l +); +cvi +;cvi++) + +95 if((* +cvi +). +v +-> + `kd +(= +Wdrd_V +) + +96 +n +. + `upde_cf +( +wlols +[ +dlols +. + `dex +((* +cvi +). +v +)], + +97 (* +cvi +). +cf +); + +99 if((* +cvi +). +v +-> + `kd +(= +Glob_V +) + +100 +n +. + `upde_cf +( +S +. + `g_lol +((* +cvi +). +v +-> + `g_glob_v +(), + +101 (* +cvi +). +v +-> + `funi_of +()), + +102 (* +cvi +). +cf +); + +104 +n +. + `upde_cf +((* +cvi +). +v +,(*cvi). +cf +); + +105 +n +. + `upde_cڡ +((* +e +). + `g_cڡ +()); + +106 +n +. + `fize +(); + +109  +GEQ_It + + `g +(* +D +); +g +; g++) + +110 if(( + `max_fs_y +(* +g +> 0= +kp_fs +) { + +111 +GEQ_Hd + +n + = + +-> + `add_GEQ +(); + +112  +Cڡr_Vs_Ir + + `cvi +(* +g +, +l +); +cvi +;cvi++) + +113 if((* +cvi +). +v +-> + `kd +(= +Wdrd_V +) + +114 +n +. + `upde_cf +( +wlols +[ +dlols +. + `dex +((* +cvi +). +v +)], + +115 (* +cvi +). +cf +); + +117 if((* +cvi +). +v +-> + `kd +(= +Glob_V +) + +118 +n +. + `upde_cf +( +S +. + `g_lol +((* +cvi +). +v +-> + `g_glob_v +(), + +119 (* +cvi +). +v +-> + `funi_of +()), + +120 (* +cvi +). +cf +); + +122 +n +. + `upde_cf +((* +cvi +). +v +,(*cvi). +cf +); + +123 +n +. + `upde_cڡ +((* +g +). + `g_cڡ +()); + +124 +n +. + `fize +(); + +127 +S +. + `fize +(); + +130  +w_ts +; + +131 + } +} + +134 +RTue + + $r_funi_symbs +( +STue + & +ts +) { + +135  + `fr_funi_symbs +( +ts +, +l +); + +136 + } +} + +138 +RTue + + $exa_funi_symbs +( +STue + & +ts +) { + +139  + `fr_funi_symbs +( +ts +, +ue +); + +140 + } +} + +143 + gd +:: +rg + + $MMGeCode +( +RTue + & +T +, +STue + & +d_IS +, +Ri + & +known +,  +efft +) { + +144 +Tue +< +CG_ouutRr + *> +meInfo +; + +145  +mt + = 1; stm< +T +. + `size +(); stmt++) + +146 +meInfo +. + `nd +( +w + + `CG_rgRr +("s" + + `to_rg +( +mt +))); + +148 +CG_rgBud + +ocg +; + +149 +CG_rgRr + * +sRr + = +ic_ +( + `MMGeCode +(& +ocg +, +T +, +d_IS +, +meInfo +, +known +, +efft +)); + +151  +i + = 1; i < +meInfo +. + `size +(); i++) + +152 +de + +meInfo +[ +i +]; + +153 i( +sRr + ! +NULL +) + +154  + `GSg +( +sRr +); + +156  +d +:: + `rg +(); + +157 + } +} + +163 +CG_ouutRr +* +MMGeCode +( +CG_ouutBud +* +ocg +, +RTue + & +T +, +STue + & +d_IS +, cڡ +Tue + & +mt_cڋ +, +Ri + & +known +,  +efft +) { + +164  + gmts + = +T +. +size +(); + +165 i( + gmts + == 0) + +166  +ocg +-> +CeCommt +(1, "No statements found!"); + +167 i(! + gknown +. +is_nu +()) + +168 + gknown +. +simify +(); + +171  + gmaxStmt + = 1; + +172 + gϡ_v + = 0; + +173  + gmt + = 1; stm< +mts +; stmt++) { + +174  + gd_dim + = +T +[ +mt +]. +n_out +(); + +175 i( + gd_dim + > + gϡ_v +) + +176 + gϡ_v + = +d_dim +; + +178  + gi + = 1; i < +d_IS +[ +mt +]. +n_t +(); i++) + +179 + gT +[ +mt +]. +me_put_v +( +i +, +d_IS +[mt]. +t_v +(i)-> +me +()); + +180  + gi + = 1; i < +d_dim +; i++) + +181 + gT +[ +mt +]. +me_ouut_v +( +i +, +d +:: +rg +("t")+ +to_rg +(i)); + +182 + gT +[ +mt +]. +tup_mes +(); + +184 +Ri + + gR + = +Rge +( +Reri_Doma +( +cy +( +T +[ +mt +]), cy( +d_IS +[stmt]))); + +185 + gR +. +simify +(); + +186  + gR +. +is_u_bound_tisfb +()) { + +187 + gw_IS +. +lo +( +maxStmt +); + +188 + gsfmis +. +lo +( +maxStmt +); + +189 + gemtInfo +. +lo +( +maxStmt +); + +190 +DNF + * + gdnf + = +R +. +quy_DNF +(); + +191 +DNF_It + +c +( +dnf +); + +192 +Ri + + gR2 + = Ri( +R +, * +c +); + +193 + gR2 +. +simify +(); + +194 i( + gR2 +. +is_exa +()) + +195 +throw + +codeg_r +("unknown constraint inoop bounds"); + +196 i( + gknown +. +is_nu +()) { + +197 + gw_IS +[ +maxStmt +] = +R2 +; + +198 + gsfmis +[ +maxStmt +] = +T +[ +mt +]; + +199 + gemtInfo +[ +maxStmt +] = +mt_cڋ +[ +mt +]; + +200 + gmaxStmt +++; + +203 +Ri + + gR2_exnded + = +cy +( +R2 +); + +204 +Ri + + gknown_exnded + = +cy +( +known +); + +205 i( + gR2 +. +n_t +(> + gknown +.n_set()) + +206 + gknown_exnded + = +Exnd_S +( +known_exnded +, +R2 +. +n_t +()- +known +.n_set()); + +207 i( + gR2 +. +n_t +(< + gknown +.n_set()) + +208 + gR2_exnded + = +Exnd_S +( +R2_exnded +, +known +. +n_t +()- +R2 +.n_set()); + +209 i( +Ii +( +R2_exnded +, +known_exnded +). +is_u_bound_tisfb +()) { + +210 + gw_IS +[ +maxStmt +] = +R2 +; + +211 + gsfmis +[ +maxStmt +] = +T +[ +mt +]; + +212 + gemtInfo +[ +maxStmt +] = +mt_cڋ +[ +mt +]; + +213 + gmaxStmt +++; + +216 + gc +. +xt +(); + +217 i(! + gc +. +live +()) + +219 if( + gcode_g_debug +) { + +220 +rtf +( +DebugFe +, "splitting iteration space for disjoint form\n"); + +221 +rtf +( +DebugFe +, "Original iteration space: \n"); + +222 + gR +. +t_wh_subs +( +DebugFe +); + +223 +rtf +( +DebugFe +, "First conjunct: \n"); + +224 + gR2 +. +t_wh_subs +( +DebugFe +); + +226 +Ri + +mad +( +R +, * +c +); + +227 + gc +. +xt +(); + +228  + gc +. +live +()) { + +229 + gmad + = +Uni +( +mad +, +Ri +( +R +, * +c +)); + +230 + gc +. +xt +(); + +232 + gR + = +Difn +( +mad +, +cy +( +R2 +)); + +233 + gR +. +simify +(); + +234 if( + gcode_g_debug +) { + +235 +rtf +( +DebugFe +, "Remaining iteration space: \n"); + +236 + gR +. +t_wh_subs +( +DebugFe +); + +242 + gmts + = +maxStmt +-1; + +243 if( + gmts + == 0) + +244  +ocg +-> +CeCommt +(1, "Nooints inny ofhe iteration spaces!"); + +247  + gmt + = 1; stm< +mts +; stmt++) { + +248  + gd_dim + = +w_IS +[ +mt +]. +n_t +(); + +249 i( + gd_dim + < + gϡ_v +) { + +250 + gw_IS +[ +mt +] = +Exnd_S +( +w_IS +[mt], +ϡ_v +- +d_dim +); + +251 +F_And + * + gf_ro + = +w_IS +[ +mt +]. +d_wh_d +(); + +252  + gi + = +d_dim ++1; i < +ϡ_v +; i++) { + +253 +EQ_Hd + + gh + = +f_ro +-> +add_EQ +(); + +254 + gh +. +upde_cf +( +w_IS +[ +mt +]. +t_v +( +i +), 1); + +255 + gh +. +upde_cڡ +( +posInfy +); + +261 if( + gknown +. +is_nu +()) { + +262 + gknown + = +Ri +:: +True +( +ϡ_v +); + +264 + gknown + = +Exnd_S +( +known +, +ϡ_v +-known. +n_t +()); + +265  + gi + = 1; i < +ϡ_v +; i++) + +266 + gknown +. +me_t_v +( +i +, +d +:: +rg +("t")+ +to_rg +(i)); + +267 + gknown +. +tup_mes +(); + +270 + gojeed_nIS +. +r +(); + +271 + gojeed_nIS +. +lo +( +ϡ_v +); + +272  + gi + = 1; i < +ϡ_v +; i++ ) { + +273 + gojeed_nIS +[ +i +]. +lo +( +mts +); + +275  + gmt + = 1; stm< +mts +; stmt++) { + +276 i( + gϡ_v + > 0) + +277 + gojeed_nIS +[ +ϡ_v +][ +mt +] = +w_IS +[stmt]; + +278  + gi + = +ϡ_v +-1; i >= 1; i--) { + +279 + gojeed_nIS +[ +i +][ +mt +] = +Proje +( +cy +( +ojeed_nIS +[i+1][mt]), i+1, +S_V +); + +280 + gojeed_nIS +[ +i +][ +mt +]. +simify +(); + +285 +ITue + +lStmts +( +mts +); + +286  + gi + = 1; i < +mts +; i++) + +287 + glStmts +[ +i +] = 1; + +288 +CG_su + * + gcg + = +g_cursive +(1, +lStmts +); + +291 + gcg + = +cg +-> +compu +( +known +, known); + +292 + gcg + = +cg +-> +f_fe_bounds +(); + +295  + gi + = 1; i < +m +( +efft +, +cg +-> +dth +()); i++) + +296 + gcg + = +cg +-> +liOvhd +( +i +); + +299 + gcg +-> +hoiGud +(); + +303 +CG_ouutRr +* + gsRr + = +cg +-> +tRr +( +ocg +, 1, +d +:: +ve +( +ϡ_v +)); + +304 +de + + gcg +; + +305 + gcg + = +NULL +; + +306 + gojeed_nIS +. +r +(); + +307 + gsfmis +. +r +(); + +308 + gw_IS +. +r +(); + +310  + gsRr +; + +314 +CG_ouutRr +* +MMGeCode +( +CG_ouutBud +* +ocg +, +RTue + & +T +, +STue + & +d_IS +, + +315 cڡ +Tue +< +CG_ouutRr + *> & +mt_cڋ +, +Ri + & +known +, + +316 +Tue +< +ITue + >& +smtNSLevs_ +, + +317 +d +:: +ve +< std:: + +<, std:: +rg +> > +syncs_ +, + +318 cڡ +Tue +< Tue< +d +:: +rg +> >& +loIdxNames_ +, + +319  +efft +) { + +320  + gmts + = +T +. +size +(); + +321 i( + gmts + == 0) + +322  +ocg +-> +CeCommt +(1, "No statements found!"); + +323 i(! + gknown +. +is_nu +()) + +324 + gknown +. +simify +(); + +328 + gsmtNSLevs + = +smtNSLevs_ +; + +329 + gsyncs + = +syncs_ +; + +330 + gloIdxNames + = +loIdxNames_ +; + +336  + gmaxStmt + = 1; + +337 + gϡ_v + = 0; + +338  + gmt + = 1; stm< +mts +; stmt++) { + +339  + gd_dim + = +T +[ +mt +]. +n_out +(); + +340 i( + gd_dim + > + gϡ_v +) + +341 + gϡ_v + = +d_dim +; + +343  + gi + = 1; i < +d_IS +[ +mt +]. +n_t +(); i++) + +344 + gT +[ +mt +]. +me_put_v +( +i +, +d_IS +[mt]. +t_v +(i)-> +me +()); + +345  + gi + = 1; i < +d_dim +; i++) + +346 + gT +[ +mt +]. +me_ouut_v +( +i +, +d +:: +rg +("t")+ +to_rg +(i)); + +347 + gT +[ +mt +]. +tup_mes +(); + +349 +Ri + + gR + = +Rge +( +Reri_Doma +( +cy +( +T +[ +mt +]), cy( +d_IS +[stmt]))); + +350 + gR +. +simify +(); + +351  + gR +. +is_u_bound_tisfb +()) { + +352 + gw_IS +. +lo +( +maxStmt +); + +353 + gsfmis +. +lo +( +maxStmt +); + +354 + gemtInfo +. +lo +( +maxStmt +); + +357 + gsmtNSLevs +. +lo +( +maxStmt +); + +361 +DNF + * + gdnf + = +R +. +quy_DNF +(); + +362 +DNF_It + +c +( +dnf +); + +363 +Ri + + gR2 + = Ri( +R +, * +c +); + +364 + gR2 +. +simify +(); + +365 i( + gR2 +. +is_exa +()) + +366 +throw + +codeg_r +("unknown constraint inoop bounds"); + +367 i( + gknown +. +is_nu +()) { + +368 + gw_IS +[ +maxStmt +] = +R2 +; + +369 + gsfmis +[ +maxStmt +] = +T +[ +mt +]; + +370 + gemtInfo +[ +maxStmt +] = +mt_cڋ +[ +mt +]; + +371 + gmaxStmt +++; + +374 +Ri + + gR2_exnded + = +cy +( +R2 +); + +375 +Ri + + gknown_exnded + = +cy +( +known +); + +376 i( + gR2 +. +n_t +(> + gknown +.n_set()) + +377 + gknown_exnded + = +Exnd_S +( +known_exnded +, +R2 +. +n_t +()- +known +.n_set()); + +378 i( + gR2 +. +n_t +(< + gknown +.n_set()) + +379 + gR2_exnded + = +Exnd_S +( +R2_exnded +, +known +. +n_t +()- +R2 +.n_set()); + +380 i( +Ii +( +R2_exnded +, +known_exnded +). +is_u_bound_tisfb +()) { + +381 + gw_IS +[ +maxStmt +] = +R2 +; + +382 + gsfmis +[ +maxStmt +] = +T +[ +mt +]; + +383 + gemtInfo +[ +maxStmt +] = +mt_cڋ +[ +mt +]; + +384 + gmaxStmt +++; + +387 + gc +. +xt +(); + +388 i(! + gc +. +live +()) + +390 if( + gcode_g_debug +) { + +391 +rtf +( +DebugFe +, "splitting iteration space for disjoint form\n"); + +392 +rtf +( +DebugFe +, "Original iteration space: \n"); + +393 + gR +. +t_wh_subs +( +DebugFe +); + +394 +rtf +( +DebugFe +, "First conjunct: \n"); + +395 + gR2 +. +t_wh_subs +( +DebugFe +); + +397 +Ri + +mad +( +R +, * +c +); + +398 + gc +. +xt +(); + +399  + gc +. +live +()) { + +400 + gmad + = +Uni +( +mad +, +Ri +( +R +, * +c +)); + +401 + gc +. +xt +(); + +403 + gR + = +Difn +( +mad +, +cy +( +R2 +)); + +404 + gR +. +simify +(); + +405 if( + gcode_g_debug +) { + +406 +rtf +( +DebugFe +, "Remaining iteration space: \n"); + +407 + gR +. +t_wh_subs +( +DebugFe +); + +413 + gmts + = +maxStmt +-1; + +414 if( + gmts + == 0) + +415  +ocg +-> +CeCommt +(1, "Nooints inny ofhe iteration spaces!"); + +418  + gmt + = 1; stm< +mts +; stmt++) { + +419  + gd_dim + = +w_IS +[ +mt +]. +n_t +(); + +420 i( + gd_dim + < + gϡ_v +) { + +421 + gw_IS +[ +mt +] = +Exnd_S +( +w_IS +[mt], +ϡ_v +- +d_dim +); + +422 +F_And + * + gf_ro + = +w_IS +[ +mt +]. +d_wh_d +(); + +423  + gi + = +d_dim ++1; i < +ϡ_v +; i++) { + +424 +EQ_Hd + + gh + = +f_ro +-> +add_EQ +(); + +425 + gh +. +upde_cf +( +w_IS +[ +mt +]. +t_v +( +i +), 1); + +426 + gh +. +upde_cڡ +( +posInfy +); + +432 if( + gknown +. +is_nu +()) { + +433 + gknown + = +Ri +:: +True +( +ϡ_v +); + +435 + gknown + = +Exnd_S +( +known +, +ϡ_v +-known. +n_t +()); + +436  + gi + = 1; i < +ϡ_v +; i++) + +437 + gknown +. +me_t_v +( +i +, +d +:: +rg +("t")+ +to_rg +(i)); + +438 + gknown +. +tup_mes +(); + +441 + gojeed_nIS +. +r +(); + +442 + gojeed_nIS +. +lo +( +ϡ_v +); + +443  + gi + = 1; i < +ϡ_v +; i++ ) { + +444 + gojeed_nIS +[ +i +]. +lo +( +mts +); + +446  + gmt + = 1; stm< +mts +; stmt++) { + +447 i( + gϡ_v + > 0) + +448 + gojeed_nIS +[ +ϡ_v +][ +mt +] = +w_IS +[stmt]; + +449  + gi + = +ϡ_v +-1; i >= 1; i--) { + +450 + gojeed_nIS +[ +i +][ +mt +] = +Proje +( +cy +( +ojeed_nIS +[i+1][mt]), i+1, +S_V +); + +451 + gojeed_nIS +[ +i +][ +mt +]. +simify +(); + +456 +ITue + +lStmts +( +mts +); + +457  + gi + = 1; i < +mts +; i++) + +458 + glStmts +[ +i +] = 1; + +459 +CG_su + * + gcg + = +g_cursive +(1, +lStmts +); + +462 + gcg + = +cg +-> +compu +( +known +, known); + +463 + gcg + = +cg +-> +f_fe_bounds +(); + +466  + gi + = 1; i < +m +( +efft +, +cg +-> +dth +()); i++) + +467 + gcg + = +cg +-> +liOvhd +( +i +); + +470 + gcg +-> +hoiGud +(); + +474 +CG_ouutRr +* + gsRr + = +cg +-> +tRr +( +ocg +, 1, +d +:: +ve +( +ϡ_v + )); + +475 +de + + gcg +; + +476 + gcg + = +NULL +; + +477 + gojeed_nIS +. +r +(); + +478 + gsfmis +. +r +(); + +479 + gw_IS +. +r +(); + +481  + gsRr +; + +484 +CG_su + * + $g_cursive +( +v +, +ITue + & +isAive +) { + +485  +mts + = +isAive +. + `size +(); + +487 +S +<> +aive +; + +488  +s +; + +489  +s + = 1; s < +mts +; s++) + +490 if( +isAive +[ +s +] +aive +. + ` +(s); + +492 + `as + ( +aive +. + `size +() >= 1); + +493 if( +v + > +ϡ_v + +w + + `CG_af +( +isAive +); + +495 i( +aive +. + `size +() == 1) + +496  +w + + `CG_lo +( +isAive +, +v +, + `g_cursive +(level+1,isActive)); + +498 +bo + +cڡtLev + = +ue +; + +500  +_l_size +; + +501 +cf_t + +t +, +fish +; + +502 +fish + = -( +posInfy +-1); + +503 +t + = +posInfy +; + +504 +Tue +< +cf_t +> + `wh +( +mts +); + +505  +s +=1; s<= +mts +; s++i( +isAive +[s]) { + +506 +cf_t + +lb +, +ub +; + +507 +_l_size + = +ojeed_nIS +[ +v +][ +s +]. + `n_t +(); + +508 +ojeed_nIS +[ +v +][ +s +]. + `sg_cjun +() + +509 -> + `quy_vb_bounds +( + +510 +ojeed_nIS +[ +v +][ +s +]. + `t_v +(level), + +511 +lb +, +ub +); + +512 if( +code_g_debug +) { + +513 + `rtf +( +DebugFe +, "IS%d: " +cf_fmt + " 0 +_l + = + `Comemt +(test_rel); + +602 if( +code_g_debug +) { + +603 + `rtf +( +DebugFe +, "Csidg s from stm%d:\n", +s +); + +604 +_l +. + `efix_t +( +DebugFe +); + +607 +fChunk +[ +s +] = +sign + <= 0; + +608 +cdChunk +[ +s +] = +sign + > 0; + +609  +numbF + = +sign + <= 0; + +610  +numbSecd + = +sign + > 0; + +612  +s2 + = 1; s2 < +isAive +. + `size +(); s2++) + +613 i( +isAive +[ +s2 +] && s2 ! +s +) { + +614 if( +code_g_debug +) + +615 + `rtf +( +DebugFe +,"Csid stm%d\n", +s2 +); + +616 +bo + +t + = + `Ii +( + `cy +( +ojeed_nIS +[ +v +][ +s2 +]), + +617 + `cy +( +_l +)). + `is_u_bound_tisfb +(); + +618 +bo + +f + = + `Difn +( + `cy +( +ojeed_nIS +[ +v +][ +s2 +]), + +619 + `cy +( +_l +)). + `is_u_bound_tisfb +(); + +620 + `as +( +t + || +f +); + +621 if( +code_g_debug + && +t +&& +f +) + +622 + `rtf +( +DebugFe +, "Sshem%d\n", +s2 +); + +623 i( +t +&& +f + +xtGEQ +; + +624 if( +code_g_debug +) { + +625 i( +t +) + +626 + `rtf +( +DebugFe +, "uf stm%d\n", +s2 +); + +628 + `rtf +( +DebugFe +, "l f stm%d\n", +s2 +); + +630 i( +t + +numbF +++; + +631 +numbSecd +++; + +632 +fChunk +[ +s2 +] = +t +; + +633 +cdChunk +[ +s2 +] = ! +t +; + +636 + `as +( +numbF ++ +numbSecd +>1 && "Can't handle wildcard in iteration space"); + +637 if( +code_g_debug +) + +638 + `rtf +( +DebugFe +, "%drue, %d false\n", + +639 +numbF +, + +640 +numbSecd +); + +641 i( +numbF + && +numbSecd +) { + +643  +w + + `CG_l +( +isAive +, +v +, +_l +, + +644 + `g_cursive +( +v +, +fChunk +), + +645 + `g_cursive +( +v +, +cdChunk +)); + +647 +xtGEQ +: ; + +653  +w + + `CG_lo +( +isAive +, +v +, + `g_cursive +(level+1,isActive)); + +654 + } +} + + @output_repr.cc + +16  + ~ + +17  + ~ + +18  + ~ + +19  + ~ + +20  + ~ + +21  + ~ + +22  + ~ + +24 +mea + + gomega + { + +26 +Tue + > +ojeed_nIS +; + +27  + gv_subuti_thshd + = 100; + +29  +uBoundFLev +; + +30  +lowBoundFLev +; + +31 +bo + +flInBounds +; + +37 +mea + + gomega + { + +39 + gd +:: + +< +EQ_Hd +, > +fd_sime_assignmt +(cڡ +Ri + & +R_ +, +Vb_ID + +v +, cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +); + +42 + gmea + { + +47  +g_ride +(cڡ +Cڡt_Hd + & +h +, +Vb_ID + & +wc +, +cf_t + & + +){ + +48 + gwc + = 0; + +49  +Cڡr_Vs_Ir + +i +( +h +, +ue +); + gi +; i++) { + +50 +as +( +wc + == 0); + +51 + gwc + = (* +i +). +v +; + +52 + g + = ((* +i +). +cf +); + +58 +CG_ouutRr +* +ouutIdt +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +R_ +, +Vb_ID + +v +, cڡ +d +:: +ve + & +assigd__the_y +) { + +59 +Ri + & +R + = +cڡ_ +( +R_ +); + +61  + gv +-> +kd +()) { + +62  + gS_V +: { + +63  +pos + = +v +-> +g_posi +(); + +64 i( + gassigd__the_y +[ +pos +-1] ! +NULL +) + +65  +assigd__the_y +[ +pos +-1]-> +e +(); + +67  + gocg +-> +CeIdt +( +v +-> +me +()); + +70  + gGlob_V +: { + +71 i( +v +-> +g_glob_v +()-> +y +() == 0) + +72  +ocg +-> +CeIdt +( +v +-> +me +()); + +76  + gy + = +v +-> +g_glob_v +()-> +y +(); + +78 + gTue +< + gCG_ouutRr + *> + ggLi +; + +82  + gi + = 1; i < +y +; i++) + +83 + ggLi +. +nd +( +ocg +-> +CeIdt +( +R +. +t_v +( +i +)-> +me +())); + +84 +CG_ouutRr + * + g + = +ocg +-> +CeInvoke +( +v +-> +g_glob_v +()-> +ba_me +(), +gLi +); + +85  + g +; + +90 +throw + +d +:: +vid_gumt +("wrong variableype"); + +101 + gd +:: + +< +CG_ouutRr + *, + gbo +> +ouutAssignmt +( +CG_ouutBud + * +ocg +, cڡ +Ri + & +R_ +, +Vb_ID + +v +, Ri & +fd +, CG_ouutR*& +if_ +, cڡ +d +:: +ve + & +assigd__the_y +) { + +102 +Ri + & +R + = +cڡ_ +( +R_ +); + +104 +Cjun + * + gc + = +R +. +quy_DNF +()-> +sg_cjun +(); + +107  +EQ_It + +ei +( +c +); + gei +;i++) + +108 i(!(* + gei +). +has_wdrds +(&& +abs +((* +ei +). +g_cf +( +v +)) > 1) { + +109 +Ri + +r +( +R +. +n_t +()); + +110 +F_And + * + gf_sur_ro + = +r +. +add_d +(); + +111 +F_Exis + * + g + = +f_sur_ro +-> +add_exis +(); + +112 +Vb_ID + + ge + = + +-> +dee +(); + +113 +F_And + * + gf_ro + = + +-> +add_d +(); + +114 +EQ_Hd + + gh + = +f_ro +-> +add_EQ +(); + +115  +Cڡr_Vs_Ir + +cvi +(* +ei +); + gcvi +; cvi++) + +116 (* + gcvi +). + gv +-> +kd +()) { + +117  + gIut_V +: { + +118 i((* +cvi +). +v + = +v +) + +119 +h +. +upde_cf +( +e +, (* +cvi +). +cf +); + +121 + gh +. +upde_cf +( +r +. +t_v +((* +cvi +). +v +-> +g_posi +()), (*cvi). +cf +); + +124  + gGlob_V +: { + +125 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +126 +Vb_ID + + gv2 +; + +127 i( + gg +-> +y +() == 0) + +128 +v2 + = +r +. +g_lol +( +g +); + +130 + gv2 + = +r +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +131 + gh +. +upde_cf +( +v2 +, (* +cvi +). +cf +); + +135 +as +(0); + +137 + gh +. +upde_cڡ +((* +ei +). +g_cڡ +()); + +139 + gr +. +cy_mes +( +R +); + +140 + gr +. +tup_mes +(); + +143 i(! +Gi +( +r +, +cy +( +fd +), 1). +is_obvious_utogy +()) { + +144 +cf_t + + gcf + = (* +ei +). +g_cf +( +v +); + +145 +cf_t + + gsign + = -(( +cf +>0)?1:-1); + +146 + gcf + = +abs +( +cf +); + +148 +CG_ouutRr + * + grm + = +NULL +; + +149  +Cڡr_Vs_Ir + +cvi +(* +ei +); + gcvi +; cvi++) + +150 i((* + gcvi +). + gv + ! +v +) { + +151 +CG_ouutRr + * +vRr + = +ouutIdt +( +ocg +, +R +, (* +cvi +). +v +, +assigd__the_y +); + +152 +cf_t + + gt + = +sign +*(* +cvi +). +cf +; + +153 i( + gt + == 1) + +154 +rm + = +ocg +-> +CePlus +єm, +vRr +); + +155 i( + gt + == -1) + +156 +rm + = +ocg +-> +CeMus +єm, +vRr +); + +157 i( + gt + > 0) + +158 + grm + = +ocg +-> +CePlus +( +rm +, ocg-> +CeTimes +(ocg-> +CeI +( +t +), +vRr +)); + +159 i( + gt + < 0) + +160 + grm + = +ocg +-> +CeMus +( +rm +, ocg-> +CeTimes +(ocg-> +CeI +(- +t +), +vRr +)); + +162 +cf_t + + gt + = +sign +*(* +ei +). +g_cڡ +(); + +163 i( + gt + > 0) + +164 + grm + = +ocg +-> +CePlus +( +rm +, ocg-> +CeI +( +t +)); + +165 i( + gt + < 0) + +166 + grm + = +ocg +-> +CeMus +( +rm +, ocg-> +CeI +(- +t +)); + +168 + grm + = +ocg +-> +CeIegMod +( +rm +, ocg-> +CeI +( +cf +)); + +169 + grm + = +ocg +-> +CeEQ +( +rm +, ocg-> +CeI +(0)); + +171 + gif_ + = +ocg +-> +CeAnd +( +if_ +, +rm +); + +174 + gfd +. +d_wh_EQ +(* +ei +); + +175 + gfd +. +simify +(); + +179 + gd +:: + +< +EQ_Hd +, > + ga + = +fd_sime_assignmt +( +R +, +v +, +assigd__the_y +); + +182 i( + ga +. + gcd + < + gINT_MAX +) { + +183 +EQ_Hd + + geq + = +a +. +f +; + +184 +CG_ouutRr + * + gr_ + = +NULL +; + +186 +cf_t + + gdivid + = +eq +. +g_cf +( +v +); + +187  + gsign + = 1; + +188 i( + gdivid + < 0) { + +189 + gdivid + = - +divid +; + +190 + gsign + = -1; + +193  +Cڡr_Vs_Ir + +cvi +( +eq +); + gcvi +; cvi++) + +194 i((* + gcvi +). + gv + ! +v +) { + +195 +CG_ouutRr + * +v_ + = +ouutIdt +( +ocg +, +R +, (* +cvi +). +v +, +assigd__the_y +); + +196 +cf_t + + gcf + = (* +cvi +). +cf +; + +197 i(- +sign + * + gcf + == -1) + +198 +r_ + = +ocg +-> +CeMus +_, +v_ +); + +199 i(- +sign + * + gcf + < -1) + +200 + gr_ + = +ocg +-> +CeMus +( +r_ +, ocg-> +CeTimes +(ocg-> +CeI +( +sign + * +cf +), +v_ +)); + +201 i(- +sign + * + gcf + == 1) + +202 +r_ + = +ocg +-> +CePlus +_, +v_ +); + +204 + gr_ + = +ocg +-> +CePlus +( +r_ +, ocg-> +CeTimes +(ocg-> +CeI +(- +sign + * +cf +), +v_ +)); + +207 +cf_t + + gc_rm + = -( +eq +. +g_cڡ +(* +sign +); + +209 i( + gc_rm + > 0) + +210 + gr_ + = +ocg +-> +CePlus +( +r_ +, ocg-> +CeI +( +c_rm +)); + +211 i( + gc_rm + < 0) + +212 + gr_ + = +ocg +-> +CeMus +( +r_ +, ocg-> +CeI +(- +c_rm +)); + +213 i( + gr_ + = +NULL +) + +214 +r_ + = +ocg +-> +CeI +(0); + +216 i( + gdivid + != 1) + +217 +r_ + = +ocg +-> +CeIegDivide +_, ocg-> +CeI +( +divid +)); + +219 + gfd +. +d_wh_EQ +( +eq +); + +220 + gfd +. +simify +(); + +222 i( + ga +. + gcd + > + gv_subuti_thshd +) + +223  + gd +:: +make_ +( +r_ +, +ue +); + +225  + gd +:: +make_ +( +r_ +, +l +); + +228  + gd +:: +make_ +( +ic_ +< +CG_ouutRr + *>( +NULL +), +l +); + +237 + gTue +< + gCG_ouutRr +*> +ouutSubuti +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +R_ +, cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +238 +Ri + & +R + = +cڡ_ +( +R_ +); + +240 cڡ  + gn + = +R +. +n_out +(); + +241 + gTue +< + gCG_ouutRr +*> + goRrLi +; + +244  + gi + = 1; i < +n +; i++) { + +245 +Ri + +mpg +( +n +, 1); + +246 +F_And + * + gf_ro + = +mpg +. +add_d +(); + +247 +EQ_Hd + + gh + = +f_ro +-> +add_EQ +(); + +248 + gh +. +upde_cf +( +mpg +. +ouut_v +(1), 1); + +249 + gh +. +upde_cf +( +mpg +. +put_v +( +i +), -1); + +251 +Ri + + gS + = +Composi +( +mpg +, +cy +( +R +)); + +253 + gd +:: + +< +EQ_Hd +, > + ga + = +fd_sime_assignmt +( +S +, S. +ouut_v +(1), +assigd__the_y +); + +255 i( + ga +. + gcd + < + gINT_MAX +) { + +256  + ga +. + gcd + > 0) { + +257 +EQ_Hd + + geq + = +a +. +f +; + +258 + gd +:: +t +<> +ndides +; + +259  +Cڡr_Vs_Ir + +cvi +( +eq +); + gcvi +; cvi++) + +260 i((* + gcvi +). + gv +-> +kd +(= +Iut_V +) + +261 +ndides +. + +((* +cvi +). +v +-> +g_posi +()); + +263 +bo + + gchged + = +l +; + +264  + gd +:: +t +<>:: + + +j + = +ndides +. +beg +(); + gj + !ndides. +d +(); j++) { + +265 +Ri + + gS2 + = +Proje +( +cy +( +S +), * +j +, +Iut_V +); + +266 + gd +:: + +< +EQ_Hd +, > + ga2 + = +fd_sime_assignmt +( +S2 +, S2. +ouut_v +(1), +assigd__the_y +); + +267 i( + ga2 +. + gcd + < +a +. +cd +) { + +268 +S + = +S2 +; + +269 + ga + = +a2 +; + +270 + gchged + = +ue +; + +274 i(! + gchged +) + +279 i( + ga +. + gcd + < + gINT_MAX +) { + +280 +CG_ouutRr + * + g + = +NULL +; + +281 +EQ_Hd + + geq + = +a +. +f +; + +282 +Vb_ID + + gv + = +S +. +ouut_v +(1); + +284  + gj + = 1; j < +S +. +n_p +(); j++) + +285 + gS +. +me_put_v +( +j +, +R +. +put_v +(j)-> +me +()); + +286 + gS +. +tup_mes +(); + +288  + gd + = +eq +. +g_cf +( +v +); + +289 +as +( +d + != 0); + +290  + gsign + = ( +d +>0)?-1:1; + +291 + gd + = - +sign + * +d +; + +292  +Cڡr_Vs_Ir + +cvi +( +eq +); + gcvi +; cvi++) + +293 i((* + gcvi +). + gv + ! +v +) { + +294  +cf + = +sign + * (* +cvi +).coef; + +295 +CG_ouutRr + * + g + = +ouutIdt +( +ocg +, +S +, (* +cvi +). +v +, +assigd__the_y +); + +296 i( + gcf + > 1) + +297 + g + = +ocg +-> +CeTimes +(ocg-> +CeI +( +cf +), + +); + +298 i( + gcf + < -1) + +299 + g + = +ocg +-> +CeTimes +(ocg-> +CeI +(- +cf +), + +); + +300 i( + gcf + > 0) + +301 + g + = +ocg +-> +CePlus +( + +, + +); + +302 i( + gcf + < 0) + +303 + g + = +ocg +-> +CeMus +( + +, + +); + +306  + gc + = +sign + * +eq +. +g_cڡ +(); + +307 i( + gc + > 0) + +308 + g + = +ocg +-> +CePlus +( + +, ocg-> +CeI +( +c +)); + +309 i( + gc + < 0) + +310 + g + = +ocg +-> +CeMus +( + +, ocg-> +CeI +(- +c +)); + +311 i( + g + = +NULL +) + +312 + + = +ocg +-> +CeI +(0); + +314 i( + gd + != 1) + +315 + + = +ocg +-> +CeIegDivide +ԕr, ocg-> +CeI +( +d +)); + +317 + goRrLi +. +nd +( + +); + +320 + goRrLi +. +nd +( +NULL +); + +323  + goRrLi +; + +326 + gmea + { + +328 +Ri + +_ride__bound +( +n +, cڡ +d +:: +m +< +Vb_ID +, +cf_t +> & +lb +, cf_ +ride +) { + +329 +Ri + +su +( +n +); + +330 +F_And + * + gf_ro + = +su +. +add_d +(); + +331 +EQ_Hd + + gh + = +f_ro +-> +add_ride +( +ride +); + +333  + gd +:: +m +< +Vb_ID +, + gcf_t +>:: +cڡ_ + +i + = +lb +. +beg +(); + gi + !lb. +d +(); i++) { + +334 i( + gi +-> + gf + = +NULL +) + +335 +h +. +upde_cڡ +( +i +-> +cd +); + +337  + gi +-> + gf +-> +kd +()) { + +338  + gIut_V +: { + +339  +pos + = +i +-> +f +-> +g_posi +(); + +340 + gh +. +upde_cf +( +su +. +t_v +( +pos +), +i +-> +cd +); + +343  + gGlob_V +: { + +344 +Glob_V_ID + +g + = +i +-> +f +-> +g_glob_v +(); + +345 +Vb_ID + + gv +; + +346 i( + gg +-> +y +() == 0) + +347 +v + = +su +. +g_lol +( +g +); + +349 + gv + = +su +. +g_lol +( +g +, +i +-> +f +-> +funi_of +()); + +350 + gh +. +upde_cf +( +v +, +i +-> +cd +); + +354 +as +(0); + +359  + gsu +; + +368 +Ri + +ge_comm_ +(cڡ +Tue + & +I +, cڡ Tue<> & +aive +,  +v +, cڡ Ri & +known +) { + +369 +as +( +I +. +size +(= +aive +.size()); + +370  + gn + = 0; + +372 + gd +:: +ve +< +Ri +> +I1 +, + gI2 +; + +373  + gi + = 1; i < +I +. +size +(); i++) + +374 i( + gaive +[ +i +]) { + +375 i( + gn + == 0) + +376 +n + = +I +[ +i +]. +n_t +(); + +378 +Ri + + gr1 +; + +379 i( + gknown +. +is_nu +()) + +380 + gr1 + = +cy +( +I +[ +i +]); + +382 + gr1 + = +Ii +( +cy +( +I +[ +i +]), cy( +known +)); + +383 + gr1 +. +simify +(); + +385 + gI1 +. +push_back +( +r1 +); + +386 +Ri + + gr2 + = +Gi +( +cy +( +I +[ +i +]), cy( +known +)); + +387 +as +( +r2 +. +is_u_bound_tisfb +()); + +388 i( + gr2 +. +is_obvious_utogy +()) + +389  + gRi +:: +True +( +n +); + +390 + gI2 +. +push_back +( +r2 +); + +393 + gd +:: +ve +< +bo +> +is_exa +( +I2 +. +size +(), +ue +); + +394 + gd +:: +ve +< +cf_t +> + +( +I2 +. +size +(), 0); + +395 + gd +:: +ve +< +cf_t +> +messy_ +( +I2 +. +size +(), 0); + +396 +Vb_ID + + gt_c + = +t_v +( +v +); + +397 + gd +:: +m +< +Vb_ID +, + gcf_t +> + glb +; + +400  +size_t + + gi + = 0; i < + gI2 +. +size +(); i++) { + +401 +Cjun + * + gc + = +I2 +[ +i +]. +quy_DNF +()-> +sg_cjun +(); + +403 +bo + + gis_deged + = +l +; + +404  +EQ_It + + ge + = +c +-> +EQs +();;++) { + +405 +cf_t + + gcf + = +abs +((* +e +). +g_cf +( +t_c +)); + +406 i( + gcf + !0 && !(* +e +). +has_wdrds +()) { + +407 +is_deged + = +ue +; + +411 i( + gis_deged +) + +414  +EQ_It + + ge + = +c +-> +EQs +();;++) { + +415 i((* + ge +). +has_wdrds +()) { + +416 +cf_t + + gcf + = +abs +((* +e +). +g_cf +( +t_c +)); + +417 i( + gcf + == 0) + +419 i( + gcf + != 1) { + +420 +is_exa +[ +i +] = +l +; + +424 +cf_t + + gthis_ + = +abs +( +Cڡr_Vs_Ir +(* +e +, +ue +). +cu_cf +()); + +425 +as +( +this_ + != 1); + +427 i( + glb +. +size +() != 0) { + +428 +Ri + + + = +_ride__bound +( +n +, +lb +, +this_ +); + +429 i( +Gi +( + +, +cy +( +I1 +[ +i +])). +is_obvious_utogy +()) { + +430 i( + g +[ +i +] == 0) + +431 + +[ +i +] = +this_ +; + +433 + g +[ +i +] = +lcm +( + +[i], +this_ +); + +436 + gis_exa +[ +i +] = +l +; + +440 +Cjun + * + gc + = +I2 +[ +i +]. +quy_DNF +()-> +sg_cjun +(); + +441  +GEQ_It + + gge + = +c +-> +GEQs +(); ge; ge++) { + +442 i((* + gge +). +has_wdrds +(|| (*ge). +g_cf +( +t_c +) != 1) + +445 + gd +:: +m +< +Vb_ID +, + gcf_t +> + gcur_lb +; + +446  +Cڡr_Vs_Ir + +cv +(* +ge +); + gcv +; cv++) + +447 + gcur_lb +[ +cv +. +cu_v +()] = cv. +cu_cf +(); + +448 + gcur_lb +[ +NULL +] = (* +ge +). +g_cڡ +(); + +450 +Ri + + g + = +_ride__bound +( +n +, +cur_lb +, +this_ +); + +451 i( +Gi +( + +, +cy +( +I1 +[ +i +])). +is_obvious_utogy +()) { + +452 i( + g +[ +i +] == 0) + +453 + +[ +i +] = +this_ +; + +455 + g +[ +i +] = +lcm +( + +[i], +this_ +); + +457 + glb + = +cur_lb +; + +463 i( + glb +. +size +() == 0) { + +464 +d +:: +m +< +Vb_ID +, +cf_t +> +cur_lb +; + +465  + gwd_cou + = 0; + +466  +Cڡr_Vs_Ir + +cv +(* +e +); + gcv +; cv++) + +467 i( + gcv +. +cu_v +()-> +kd +(= +Wdrd_V +) + +468 +wd_cou +++; + +470 + gcur_lb +[ +cv +. +cu_v +()] = cv. +cu_cf +(); + +471 + gcur_lb +[ +NULL +] = (* +e +). +g_cڡ +(); + +473 i( + gwd_cou + == 1) { + +474 +lb + = +cur_lb +; + +475 i( + g +[ +i +] == 0) + +476 + +[ +i +] = +this_ +; + +478 + g +[ +i +] = +lcm +( + +[i], +this_ +); + +482 i( + glb +. +size +() == 0) + +483 +is_exa +[ +i +] = +l +; + +490 +cf_t + + gglob_ + = 0; + +491  +size_t + + gi + = 0; i < + gis_exa +. +size +(); i++) + +492 i( + gis_exa +[ +i +]) + +493 + gglob_ + = +gcd +( +glob_ +, + +[ +i +]); + +494 i( + gglob_ + == 1) + +495  +Ri +:: +True +( +n +); + +498  +size_t + + gi + = 0; i < + gI2 +. +size +(); i++) + +499 i(! + gis_exa +[ +i +]) { + +500 +Cjun + * + gc + = +I2 +[ +i +]. +quy_DNF +()-> +sg_cjun +(); + +501  +EQ_It + + ge + = +c +-> +EQs +();;++) { + +502 +cf_t + + gcf + = +abs +((* +e +). +g_cf +( +t_c +)); + +503 i( + gcf + =0 || +cf + == 1) + +507 +cf_t + + gthis_ + = +abs +( +Cڡr_Vs_Ir +(* +e +, +ue +). +cu_cf +()); + +508 + gthis_ + / +gcd +( +this_ +, +cf +); + +509 + gthis_ + = +gcd +( +glob_ +, +this_ +); + +510 i( + gthis_ + == 1) + +513 i( + glb +. +size +() != 0) { + +514 +Ri + + + = +_ride__bound +( +n +, +lb +, +this_ +); + +515 i( +Gi +( + +, +cy +( +I1 +[ +i +])). +is_obvious_utogy +()) { + +516 i( + g +[ +i +] == 0) + +517 + +[ +i +] = +this_ +; + +519 + g +[ +i +] = +lcm +( + +[i], +this_ +); + +524 +Cjun + * + gc + = +I2 +[ +i +]. +quy_DNF +()-> +sg_cjun +(); + +525  +GEQ_It + + gge + = +c +-> +GEQs +(); ge; ge++) { + +526 i((* + gge +). +has_wdrds +(|| (*ge). +g_cf +( +t_c +) != 1) + +529 + gd +:: +m +< +Vb_ID +, + gcf_t +> + gcur_lb +; + +531  +Cڡr_Vs_Ir + +cv +(* +ge +); + gcv +; cv++) + +532 + gcur_lb +[ +cv +. +cu_v +()] = cv. +cu_cf +(); + +534 + gcur_lb +[ +NULL +] = (* +ge +). +g_cڡ +(); + +536 +Ri + + g + = +_ride__bound +( +n +, +cur_lb +, +this_ +); + +537 i( +Gi +( + +, +cy +( +I1 +[ +i +])). +is_obvious_utogy +()) { + +538 i( + g +[ +i +] == 0) + +539 + +[ +i +] = +this_ +; + +541 + g +[ +i +] = +lcm +( + +[i], +this_ +); + +543 + glb + = +cur_lb +; + +552  +size_t + + gi + = 0; i < + gis_exa +. +size +(); i++) + +553 i(! + gis_exa +[ +i +]) + +554 + gglob_ + = +gcd +( +glob_ +, + +[ +i +]); + +555 i( + gglob_ + =1 || +glob_ + == 0) + +556  +Ri +:: +True +( +n +); + +558 +Ri + + gsu + = +_ride__bound +( +n +, +lb +, +glob_ +); + +561  +size_t + + gi + = 0; i < + gI1 +. +size +(); i++) + +562 i( + g +[ +i +] == 0) { + +563 i(! +Gi +( +cy +( +su +), cy( +I1 +[ +i +])). +is_obvious_utogy +()) + +564  +Ri +:: +True +( +n +); + +567  + gsu +; + +574 +CG_ouutRr +* +ouutSmt +( +CG_ouutBud + * +ocg +, CG_ouutR* +mt +,  +dt +, cڡ +Ri + & +mpg_ +, cڡ Ri & +known_ +, cڡ +d +:: +ve + & +assigd__the_y +) { + +575 +Ri + +mpg + = +cy +( +mpg_ +); + +576 +Ri + + gknown + = +cy +( +known_ +); + +577 + gTue +< + gd +:: +rg +> +lo_vs +; + +579  + gi + = 1; i < +mpg +. +n_p +(); i++) + +580 + glo_vs +. +nd +( +mpg +. +put_v +( +i +)-> +me +()); + +583 i( + gknown +. +n_t +(> + gmpg +. +n_out +()) { + +584 +Ri + +r +( +known +. +n_t +(), +mpg +. +n_out +()); + +585 +F_And + * + gf_ro + = +r +. +add_d +(); + +586  + gi + = 1; i < +mpg +. +n_out +(); i++) { + +587 +EQ_Hd + + gh + = +f_ro +-> +add_EQ +(); + +588 + gh +. +upde_cf +( +r +. +put_v +( +i +), 1); + +589 + gh +. +upde_cf +( +r +. +ouut_v +( +i +), -1); + +591 + gknown + = +Rge +( +Reri_Doma +( +r +, +known +)); + +592 + gknown +. +simify +(); + +596 +Ri + +k +( +known +. +n_t +()); + +597 +F_And + * + gf_ro + = +k +. +add_d +(); + +598 +Cjun + * + gc + = +known +. +quy_DNF +()-> +sg_cjun +(); + +599  +EQ_It + + ge + = +c +-> +EQs +();;++) { + +600 i(!(* + ge +). +has_wdrds +()) + +601 + gf_ro +-> +add_EQ +(* +e +); + +603 + gk +. +simify +(); + +606 +Ri + + gInv_mpg + = +Reri_Doma +( +Inv +( +mpg +), +k +); + +607 + gTue +< + gCG_ouutRr +*> + gsLi + = +ouutSubuti +( +ocg +, +Inv_mpg +, +assigd__the_y +); + +609  + gocg +-> +CePHd +( +dt +, +mt +, +sLi +, +lo_vs +); + +614 +bo + +fdFloIquy +( +Ri + & +r +, +Vb_ID + +v +, +GEQ_Hd + & +h +, Vb_ID +exuded +) { + +615 +Cjun + * + gc + = +r +. +sg_cjun +(); + +617 + gd +:: +t +< +Vb_ID +> +v_checked +; + +618 + gd +:: +ack +< +Vb_ID +> +v_checkg +; + +619 + gv_checkg +. +push +( +v +); + +621 ! + gv_checkg +. +emy +()) { + +622 +Vb_ID + + gv2 + = +v_checkg +. +t +(); + +623 + gv_checkg +. +p +(); + +625 +bo + + gis_o + = +l +; + +626  +GEQ_It + +gi +( +c +); + ggi +; gi++) { + +627 i( + gexuded + ! +NULL + && (* +gi +). +g_cf +( +exuded +) != 0) + +630 +cf_t + + ga + = (* +gi +). +g_cf +( +v2 +); + +631 i( + ga + < 0) { + +632  +GEQ_It + +gi2 +( +c +); + ggi2 +; gi2++) { + +633 +cf_t + + gb + = (* +gi2 +). +g_cf +( +v2 +); + +634 i( + gb + =- +a + && (* +gi +). +g_cڡ +()+(* +gi2 +).get_const() < -a) { + +635 +bo + +mch + = +ue +; + +636  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) + +637 i((* + ggi2 +). +g_cf +((* +cvi +). +v +!-(*cvi). +cf +) { + +638 +mch + = +l +; + +641 i(! + gmch +) + +643  +Cڡr_Vs_Ir + +cvi +(* +gi2 +); + gcvi +; cvi++) + +644 i((* + ggi +). +g_cf +((* +cvi +). +v +!-(*cvi). +cf +) { + +645 +mch + = +l +; + +648 i( + gmch +) { + +649 + gv_checked +. + +( +v2 +); + +650 + gis_o + = +ue +; + +651 i( + gv + = +v2 +) + +652 +h + = * +gi +; + +654  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) + +655 i(((* + gcvi +). + gv +-> +kd +(= +Exis_V + || (* +cvi +). +v +->kd(= +Wdrd_V +) && + +656 +v_checked +. +fd +((* +cvi +). +v +=v_checked. +d +()) + +657 +v_checkg +. +push +((* +cvi +). +v +); + +663 i( + gis_o +) + +667 i(! + gis_o +) + +668  + gl +; + +670  + gue +; + +680 +CG_ouutRr +* +ouut_as_gud +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, +Cڡt_Hd + +e +, +bo + +is_equy +, cڡ +d +:: +ve + & +assigd__the_y +) { + +681 +Ri + & +guds + = +cڡ_ +( +guds_ +); + +682 i( + ge +. +has_wdrds +()) + +683 +throw + + gd +:: +vid_gumt +("constraint mustot have wildcard"); + +685 +Vb_ID + + gv + = (* +Cڡr_Vs_Ir +( +e +)). +v +; + +687 +cf_t + + gved_cf + = (( +e +). +g_cf +( +v +)); + +688  + gsign + = +ved_cf + < 0 ? -1 : 1; + +690 ( + ge +). +upde_cf_durg_simify +( +v +, - +ved_cf ++ +sign +); + +691 +CG_ouutRr +* + gr + = +ouutEasyBoundAsRr +( +ocg +, +guds +, +e +, +v +, +l +, 0, +assigd__the_y +); + +692 ( + ge +). +upde_cf_durg_simify +( +v +, +ved_cf +- +sign +); + +694 +CG_ouutRr +* + gl + = +ouutIdt +( +ocg +, +guds +, +v +, +assigd__the_y +); + +695 i( +abs +( +ved_cf +) != 1) + +696 +l + = +ocg +-> +CeTimes +(ocg-> +CeI +( +abs +( +ved_cf +)),op); + +699 i( + gis_equy +) { + +700  + gocg +-> +CeEQ +( +l +, +r +); + +703 i( + gved_cf + < 0) + +704  + gocg +-> +CeLE +( +l +, +r +); + +706  + gocg +-> +CeGE +( +l +, +r +); + +715 +CG_ouutRr + * +ouut_EQ_rides +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, cڡ +d +:: +ve + & +assigd__the_y +) { + +716 +Ri + +guds + = +cڡ_ +( +guds_ +); + +717 +Cjun + * + gc + = +guds +. +sg_cjun +(); + +719 +CG_ouutRr + * + geqRr + = +NULL +; + +721  +EQ_It + +ei +( +c +-> +EQs +()); + gei +;i++) { + +722 +Vb_ID + + gwc + = +NULL +; + +723  +Cڡr_Vs_Ir + +cvi +((* +ei +), +ue +); + gcvi +; cvi++) { + +724 i( + gwc + ! +NULL +) + +725 +throw + +codeg_r +("Can't generatequality condition with multiple wildcards"); + +727 + gwc + = (* +cvi +). +v +; + +729 i( + gwc + = +NULL +) + +732 +cf_t + + g + = (* +ei +). +g_cf +( +wc +); + +734 (* + gei +). +upde_cf_durg_simify +( +wc +, 1- + +); + +735 +CG_ouutRr +* + gl + = +ouutEasyBoundAsRr +( +ocg +, +guds +, (* +ei +), +wc +, +l +, 0, +assigd__the_y +); + +736 (* + gei +). +upde_cf_durg_simify +( +wc +, + +-1); + +738 +CG_ouutRr +* + gr + = +ocg +-> +CeI +( +abs +( + +)); + +739 +CG_ouutRr +* + gtMod + = +ocg +-> +CeIegMod +( +l +, +r +); + +740 +CG_ouutRr +* + geqNode + = +ocg +-> +CeEQ +( +tMod +, ocg-> +CeI +(0)); + +742 + geqRr + = +ocg +-> +CeAnd +( +eqRr +, +eqNode +); + +745  + geqRr +; + +759 +CG_ouutRr + * +ouut_GEQ_rides +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, cڡ +d +:: +ve + & +assigd__the_y +) { + +760 +Ri + +guds + = +cڡ_ +( +guds_ +); + +761 +Cjun + * + gc + = +guds +. +sg_cjun +(); + +763 +CG_ouutRr +* + ggeqRr + = +NULL +; + +765 + gd +:: +t +< +Vb_ID +> +n_ph_wdrd +; + +766  +GEQ_It + +gi +( +c +); + ggi +; gi++) { + +767  + gnum_wd + = 0; + +768 +Vb_ID + + gf_e +; + +769  +Cڡr_Vs_Ir + +cvi +(* +gi +, +ue +); + gcvi +; cvi++) { + +770 + gnum_wd +++; + +771 i( + gnum_wd + == 1) + +772 +f_e + = (* +cvi +). +v +; + +774 + gn_ph_wdrd +. + +((* +cvi +). +v +); + +776 i( + gnum_wd + > 1) + +777 + gn_ph_wdrd +. + +( +f_e +); + +780  + gi + = 1; i <(*( +c +-> +vbs +())). +size +(); i++) { + +781 +Vb_ID + + gwc + = (*( +c +-> +vbs +()))[ +i +]; + +782 i( + gwc +-> +kd +(= +Wdrd_V + && +n_ph_wdrd +. +fd +( +wc +=n_ph_wdrd. +d +()) { + +783 +Tue +< +GEQ_Hd +> +low +, +u +; + +784  +GEQ_It + +gi +( +c +); + ggi +; gi++) { + +785 if((* + ggi +). +g_cf +( +wc +) > 0) + +786 + glow +. +nd +(* +gi +); + +787 if((* + ggi +). +g_cf +( +wc +) < 0) + +788 + gu +. +nd +(* +gi +); + +793  + gTue_It +< + gGEQ_Hd +> +low +( +low +); + glow +;ow++) { + +794  + gTue_It +< + gGEQ_Hd +> +up +( +u +); + gup +; up++) { + +795 +cf_t + + glow_cf + = (* +low +). +g_cf +( +wc +); + +796 +cf_t + + gup_cf + = (* +up +). +g_cf +( +wc +); + +798 (* + glow +). +upde_cf_durg_simify +( +wc +, 1- +low_cf +); + +799 +CG_ouutRr +* + glowEx + = +ouutEasyBoundAsRr +( +ocg +, +guds +, * +low +, +wc +, +l +, 0, +assigd__the_y +); + +800 (* + glow +). +upde_cf_durg_simify +( +wc +, +low_cf +-1); + +802 (* + gup +). +upde_cf_durg_simify +( +wc +, -1- +up_cf +); + +803 +CG_ouutRr +* + gupEx + = +ouutEasyBoundAsRr +( +ocg +, +guds +, * +up +, +wc +, +l +, 0, +assigd__the_y +); + +804 (* + gup +). +upde_cf_durg_simify +( +wc +, +up_cf ++1); + +806 +CG_ouutRr +* + gtDiv + = +ocg +-> +CeIegDivide +( +upEx +, ocg-> +CeI +(- +up_cf +)); + +807 +CG_ouutRr +* + gr + = +ocg +-> +CeTimes +(ocg-> +CeI +( +low_cf +), +tDiv +); + +808 +CG_ouutRr +* + ggeqNode + = +ocg +-> +CeLE +( +lowEx +, +r +); + +810 + ggeqRr + = +ocg +-> +CeAnd +( +geqRr +, +geqNode +); + +816 i( + gn_ph_wdrd +. +size +() > 0) { + +826 +throw + +codeg_r +("Can't generate multiple wildcard GEQ guardsightow"); + +829  + ggeqRr +; + +836 +CG_ouutRr + * +ouutGud +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +guds_ +, cڡ +d +:: +ve + & +assigd__the_y +) { + +837 +Ri + & +guds + = +cڡ_ +( +guds_ +); + +838 i( + gguds +. +is_nu +(|| guds. +is_obvious_utogy +()) + +839  + gNULL +; + +841 +CG_ouutRr +* + gnodeRr + = +NULL +; + +843 +CG_ouutRr + * + geqSideRr + = +ouut_EQ_rides +( +ocg +, +guds +, +assigd__the_y +); + +844 + gnodeRr + = +ocg +-> +CeAnd +( +nodeRr +, +eqSideRr +); + +846 +CG_ouutRr + * + ggeqSideRr + = +ouut_GEQ_rides +( +ocg +, +guds +, +assigd__the_y +); + +847 + gnodeRr + = +ocg +-> +CeAnd +( +nodeRr +, +geqSideRr +); + +849 +Cjun + * + gc + = +guds +. +sg_cjun +(); + +850  +EQ_It + +ei +( +c +-> +EQs +()); + gei +;i++) + +851 i(!(* + gei +). +has_wdrds +()) { + +852 +CG_ouutRr + * + geqRr + = +ouut_as_gud +( +ocg +, +guds +, (* +ei +), +ue +, +assigd__the_y +); + +853 + gnodeRr + = +ocg +-> +CeAnd +( +nodeRr +, +eqRr +); + +855  +GEQ_It + +gi +( +c +-> +GEQs +()); + ggi +; gi++) + +856 i(!(* + ggi +). +has_wdrds +()) { + +857 +CG_ouutRr + * + ggeqRr + = +ouut_as_gud +( +ocg +, +guds +, (* +gi +), +l +, +assigd__the_y +); + +858 + gnodeRr + = +ocg +-> +CeAnd +( +nodeRr +, +geqRr +); + +861  + gnodeRr +; + +869 +CG_ouutRr + * +ouutLBasRr +( +CG_ouutBud +* +ocg +, cڡ +GEQ_Hd + & +g +, + +870 +Ri + & +bounds +, +Vb_ID + +v +, + +871 +cf_t + +ride +, cڡ +EQ_Hd + & +rideEQ +, + +872 +Ri + +known +, cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +873 #i! +defed + +NDEBUG + + +874 +cf_t + +v_cf +; + +875 +as +(( +v_cf + = +g +. +g_cf +( +v +)) > 0); + +878 + gd +:: +rg + +s +; + +879 +CG_ouutRr + * + glbRr +; + +880 i( + gride + == 1) { + +881 +lbRr + = +ouutEasyBoundAsRr +( +ocg +, +bounds +, +g +, +v +, +l +, 1, +assigd__the_y +); + +884 i(! +boundHsSide +( +g +, +v +, +rideEQ +, +ride +, +known +)) { + +885 + gbounds +. +tup_mes +(); + +887 +CG_rgBud + + goscg +; + +888 + gd +:: +rg + +c + = +GSg +( +ouutEasyBoundAsRr +(& +oscg +, +bounds +, +rideEQ +, +v +, +ue +, 0, +assigd__the_y +)); + +889 +CG_ouutRr + * + gcRr + = +NULL +; + +890 i( + gc + ! +d +:: +rg +("0")) + +891 +cRr + = +ouutEasyBoundAsRr +( +ocg +, +bounds +, +rideEQ +, +v +, +ue +, 0, +assigd__the_y +); + +892 + gd +:: +rg + +LovM + = +GSg +( +ouutEasyBoundAsRr +(& +oscg +, +bounds +, +g +, +v +, +l +, 1, +assigd__the_y +)); + +893 +CG_ouutRr + * + gLovMRr + = +NULL +; + +894 i( + gLovM + ! +d +:: +rg +("0")) + +895 +LovMRr + = +ouutEasyBoundAsRr +( +ocg +, +bounds +, +g +, +v +, +l +, 1, +assigd__the_y +); + +897 i( + gcode_g_debug + > 2) { + +898 +rtf +( +DebugFe +,"::: LovM i%s\n", +LovM +. +c_r +()); + +899 +rtf +( +DebugFe +,"::: c i%s\n", +c +. +c_r +()); + +902  + gcomexy1 + = 0, + gcomexy2 + = 0; + +903  +size_t + + gi + = 0; i < + gc +. +ngth +(); i++) + +904 i( + gc +[ +i +] ='+' || +c +[i] == '-' || c[i] == '*' || c[i] == '/') + +905 +comexy1 +++; + +906 i( + gc +[ +i +] == ',') + +907 +comexy1 + += 2; + +908  +size_t + + gi + = 0; i < + gLovM +. +ngth +(); i++) + +909 i( + gLovM +[ +i +] ='+' || +LovM +[i] == '-' || LoverM[i] == '*' || LoverM[i] == '/') + +910 +comexy2 +++; + +911 i( + gLovM +[ +i +] == ',') + +912 +comexy2 + += 2; + +914 i( + gcomexy1 + < + gcomexy2 +) { + +915 +CG_ouutRr + * + gidUp + = +LovMRr +; + +916 +CG_ouutRr + * + gc1Rr + = +ocg +-> +CeCy +( +cRr +); + +917 + gidUp + = +ocg +-> +CeMus +( +idUp +, +c1Rr +); + +918 + gidUp + = +ocg +-> +CePlus +( +idUp +, ocg-> +CeI +( +ride +-1)); + +919 +CG_ouutRr + * + gidLow + = +ocg +-> +CeI +( +ride +); + +920 + glbRr + = +ocg +-> +CeTimes +(ocg-> +CeI +( +ride +), + +921 +ocg +-> +CeIegDivide +( +idUp +, +idLow +)); + +922 + glbRr + = +ocg +-> +CePlus +( +lbRr +, +cRr +); + +925 +CG_ouutRr + * + gLovM1Rr + = +ocg +-> +CeCy +( +LovMRr +); + +926 +CG_ouutRr + * + gimUp + = +ocg +-> +CeMus +( +cRr +, +LovM1Rr +); + +927 +CG_ouutRr + * + gimLow + = +ocg +-> +CeI +( +ride +); + +928 +CG_ouutRr + * + gtMod + = +ocg +-> +CeIegMod +( +imUp +, +imLow +); + +929 + glbRr + = +ocg +-> +CePlus +( +LovMRr +, +tMod +); + +934 + gbounds +. +tup_mes +(); + +935 + glbRr + = +ouutEasyBoundAsRr +( +ocg +, +bounds +, +g +, +v +, +l +, 0, +assigd__the_y +); + +939  + glbRr +; + +946 +CG_ouutRr + * +ouutUBasRr +( +CG_ouutBud +* +ocg +, cڡ +GEQ_Hd + & +g +, + +947 +Ri + & +bounds +, + +948 +Vb_ID + +v +, + +949 +cf_t + , + +950 cڡ +EQ_Hd + & , + +951 cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +952 +as +( +g +. +g_cf +( +v +) < 0); + +953 +CG_ouutRr +* + gupRr + = +ouutEasyBoundAsRr +( +ocg +, +bounds +, +g +, +v +, +l +, 0, +assigd__the_y +); + +954  + gupRr +; + +966 +CG_ouutRr +* +ouutEasyBoundAsRr +( +CG_ouutBud +* +ocg +, +Ri + & +bounds +, + +967 cڡ +Cڡt_Hd + & +g +, +Vb_ID + +v +, + +968 +bo + +igneWC +, + +969  +g +, + +970 cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +974 +CG_ouutRr +* +syBoundRr + = +NULL +; + +976 +cf_t + + gv_cf + = +g +. +g_cf +( +v +); + +977  + gv_sign + = +v_cf + > 0 ? 1 : -1; + +978 + gv_cf + * +v_sign +; + +979 +as +( +v_cf + > 0); + +982  + gsign_adj + = - +v_sign +; + +987  +Cڡr_Vs_Ir + +c2 +( +g +, +l +); + gc2 +; c2++) { + +988 i((* + gc2 +). + gv + ! +v + && (! +igneWC + || (* +c2 +). +v +-> +kd +()!= +Wdrd_V +)) { + +990 +cf_t + +cf + = (* +c2 +). +cf +* +sign_adj +; + +991 +as +( +cf + != 0); + +993 +CG_ouutRr + * + gvName +; + +994 i((* + gc2 +). + gv +-> +kd +(= +Wdrd_V +) { + +995 +GEQ_Hd + +h +; + +996 i(! +fdFloIquy +( +bounds +, (* +c2 +). +v +, +h +, +v +)) { + +997 i( + gsyBoundRr + ! +NULL +) { + +998 +syBoundRr +-> +r +(); + +999 +de + + gsyBoundRr +; + +1001  + gNULL +; + +1003 + gvName + = +ouutEasyBoundAsRr +( +ocg +, +bounds +, +h +, (* +c2 +). +v +, +l +, 0, +assigd__the_y +); + +1006 + gvName + = +ouutIdt +( +ocg +, +bounds +, (* +c2 +). +v +, +assigd__the_y +); + +1008 +CG_ouutRr + * + gcfRr + = +NULL +; + +1010 i( + gcf + > 1) { + +1011 + gcfRr + = +ocg +-> +CeI +( +cf +); + +1012 +CG_ouutRr +* + grbRr + = +ocg +-> +CeTimes +( +cfRr +, +vName +); + +1013 + gsyBoundRr + = +ocg +-> +CePlus +( +syBoundRr +, +rbRr +); + +1015 i( + gcf + < -1) { + +1016 + gcfRr + = +ocg +-> +CeI +(- +cf +); + +1017 +CG_ouutRr +* + grbRr + = +ocg +-> +CeTimes +( +cfRr +, +vName +); + +1018 + gsyBoundRr + = +ocg +-> +CeMus +( +syBoundRr +, +rbRr +); + +1020 i( + gcf + == 1) { + +1021 +syBoundRr + = +ocg +-> +CePlus +asyBoundRr, +vName +); + +1023 i( + gcf + == -1) { + +1024 +syBoundRr + = +ocg +-> +CeMus +asyBoundRr, +vName +); + +1029 i( + gg +. +g_cڡ +()) { + +1030 +cf_t + + gcf + = +g +. +g_cڡ +()* +sign_adj +; + +1031 +as +( +cf + != 0); + +1032 i( + gcf + > 0) { + +1033 + gsyBoundRr + = +ocg +-> +CePlus +( +syBoundRr +, ocg-> +CeI +( +cf +)); + +1036 + gsyBoundRr + = +ocg +-> +CeMus +( +syBoundRr +, ocg-> +CeI +(- +cf +)); + +1040 if( + gsyBoundRr + = +NULL +) { + +1041 +syBoundRr + = +ocg +-> +CeI +(0); + +1045 i( + gv_cf + > 1) { + +1046 +as +( +g + >= 0); + +1047 i( + gg +) { + +1048 + gsyBoundRr + +ocg +-> +CePlus +( +syBoundRr +, ocg-> +CeI +( +v_cf +-1)); + +1050 + gsyBoundRr + = +ocg +-> +CeIegDivide +( +syBoundRr +, ocg-> +CeI +( +v_cf +)); + +1053  + gsyBoundRr +; + +1062 + gd +:: + +< +CG_ouutRr + *, + gbo +> +ouutBounds +( +CG_ouutBud +* +ocg +, cڡ +Ri + & +bounds +, +Vb_ID + +v +,  +dt +, Ri & +fd +, cڡ +d +:: +ve + & +assigd__the_y +) { + +1063 +Ri + +b + = +cy +( +bounds +); + +1064 +Cjun + * + gc + = +b +. +quy_DNF +()-> +sg_cjun +(); + +1068 +Ri + + gr1 + = Ri:: +True +( +b +. +n_t +()), + gr2 + = Relation::True(b.n_set()); + +1069  +EQ_It + +ei +( +c +); + gei +;i++) { + +1070 i((* + gei +). +g_cf +( +v +!0 && (* +ei +). +has_wdrds +()) { + +1071 +cf_t + +sign +; + +1072 i((* + gei +). +g_cf +( +v +) > 0) + +1073 + gsign + = 1; + +1075 + gsign + = -1; + +1077 +cf_t + + gride + = 0; + +1078  +Cڡr_Vs_Ir + +cvi +(* +ei +, +ue +); + gcvi +; cvi++) + +1079 i((* + gcvi +). + gv +-> +kd +(= +Wdrd_V +) { + +1080 +ride + = +abs +((* +cvi +). +cf +); + +1085 +bo + + gfound_mch + = +l +; + +1086 i( +abs +((* +ei +). +g_cf +( +v +)) != 1) { + +1087 +cf_t + +d + = +ride + / +gcd +( +abs +((* +ei +). +g_cf +( +v +)), stride); + +1088 +Ri + + gr3 + = Ri:: +True +( +b +. +n_t +()); + +1089 + gr3 +. +d_wh_EQ +(* +ei +); + +1091  +GEQ_It + +gi +( +c +); + ggi +; gi++) { + +1092 i((* + ggi +). +g_cf +( +v +=1 && !(* +gi +). +has_wdrds +()) { + +1093 +Ri + +r4 +( +b +. +n_t +()); + +1094 +F_And + * + gf_ro + = +r4 +. +add_d +(); + +1095 +Side_Hd + + gh + = +f_ro +-> +add_ride +( +d +); + +1097  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) + +1098 (* + gcvi +). + gv +-> +kd +()) { + +1099  + gIut_V +: { + +1100  +pos + = (* +cvi +). +v +-> +g_posi +(); + +1101 + gh +. +upde_cf +( +r4 +. +t_v +( +pos +), (* +cvi +). +cf +); + +1104  + gGlob_V +: { + +1105 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +1106 +Vb_ID + + gv +; + +1107 i( + gg +-> +y +() == 0) + +1108 +v + = +r4 +. +g_lol +( +g +); + +1110 + gv + = +r4 +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1111 + gh +. +upde_cf +( +v +, (* +cvi +). +cf +); + +1115 +rtf +( +DebugFe +, "can't deal withhe variableype inower bound\n"); + +1116  + gd +:: +make_ +( +ic_ +< +CG_ouutRr + *>( +NULL +), +l +); + +1118 + gh +. +upde_cڡ +((* +gi +). +g_cڡ +()); + +1120 +Ri + + gr5 + = +Gi +( +cy +( +r3 +), +Ii +(cy( +r4 +), cy( +fd +))); + +1123 i( + gr5 +. +is_obvious_utogy +()) { + +1124 + gr1 + = +Ii +( +r1 +, +r4 +); + +1125 + gfound_mch + = +ue +; + +1132  +GEQ_It + +gi +( +c +); + ggi +; gi++) { + +1133 i((* + ggi +). +g_cf +( +v += +abs +((* +ei +).g_cf(v)&& !(* +gi +). +has_wdrds +()) { + +1134 +Ri + +r +( +b +. +n_t +()); + +1135 +Side_Hd + + gh + = +r +. +add_d +()-> +add_ride +( +ride +); + +1137  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) + +1138 (* + gcvi +). + gv +-> +kd +()) { + +1139  + gIut_V +: { + +1140  +pos + = (* +cvi +). +v +-> +g_posi +(); + +1141 i((* + gcvi +). + gv + ! +v +) { + +1142  +t1 + = +t_mod +((* +cvi +). +cf +, +ride +); + +1143 i( + gt1 + != 0) { + +1144 +cf_t + +t2 + = +fd +. +quy_vb_mod +nfd. +t_v +( +pos +), +ride +); + +1145 i( + gt2 + ! +posInfy +) + +1146 +h +. +upde_cڡ +( +t1 +* +t2 +); + +1148 + gh +. +upde_cf +( +r +. +t_v +( +pos +), +t1 +); + +1152 + gh +. +upde_cf +( +r +. +t_v +( +pos +), (* +cvi +). +cf +); + +1155  + gGlob_V +: { + +1156 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +1157 +Vb_ID + + gv +; + +1158 i( + gg +-> +y +() == 0) + +1159 +v + = +fd +. +g_lol +( +g +); + +1161 + gv + = +fd +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1162 +cf_t + + gt + = +fd +. +quy_vb_mod +( +v +, +ride +); + +1163 i( + gt + ! +posInfy +) + +1164 +h +. +upde_cڡ +( +t +*(* +cvi +). +cf +); + +1166 +Vb_ID + + gv2 +; + +1167 i( + gg +-> +y +() == 0) + +1168 +v2 + = +r +. +g_lol +( +g +); + +1170 + gv2 + = +r +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1171 + gh +. +upde_cf +( +v2 +, (* +cvi +). +cf +); + +1176 +rtf +( +DebugFe +, "can't deal withhe variableype inower bound\n"); + +1177  + gd +:: +make_ +( +ic_ +< +CG_ouutRr + *>( +NULL +), +l +); + +1179 + gh +. +upde_cڡ +((* +gi +). +g_cڡ +()); + +1181 +bo + + gt + = +ue +; + +1183 +Cjun + * + gc2 + = +r +. +quy_DNF +()-> +sg_cjun +(); + +1184 +EQ_Hd + + gh2 +; + +1185  +EQ_It + +ei2 +( +c2 +); + gei2 +;i2++) { + +1186 + gh2 + = * +ei2 +; + +1190  + gsign +; + +1191 i( + gh2 +. +g_cf +( +v +=(* +ei +).get_coef(v)) + +1192 +sign + = 1; + +1194 + gsign + = -1; + +1196 + gt + = +t_mod +( +h2 +. +g_cڡ +(- +sign + * (* +ei +).g_cڡ(), +ride +) == 0; + +1198 i( + gt + ! +l +) + +1199  +Cڡr_Vs_Ir + +cvi +( +h2 +); + gcvi +; cvi++) + +1200 i((* + gcvi +). + gv +-> +kd +(! +Wdrd_V + && + +1201 +t_mod +((* +cvi +). +cf + - +sign + * (* +ei +). +g_cf +((*cvi). +v +), +ride +) != 0) { + +1202 +t + = +l +; + +1206 i( + gt + ! +l +) + +1207  +Cڡr_Vs_Ir + +cvi +(* +ei +); + gcvi +; cvi++) + +1208 i((* + gcvi +). + gv +-> +kd +(! +Wdrd_V + && + +1209 +t_mod +((* +cvi +). +cf + - +sign + * +h2 +. +g_cf +((*cvi). +v +), +ride +) != 0) { + +1210 +t + = +l +; + +1216 i( + gt +) { + +1218 +F_And + * + gf_ro + = +r1 +. +d_wh_d +(); + +1219 +Side_Hd + + gh + = +f_ro +-> +add_ride +( +ride +); + +1220  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) + +1221 (* + gcvi +). + gv +-> +kd +()) { + +1222  + gIut_V +: { + +1223 +h +. +upde_cf +( +r1 +. +t_v +((* +cvi +). +v +-> +g_posi +()), (*cvi). +cf +); + +1226  + gGlob_V +: { + +1227 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +1228 +Vb_ID + + gv +; + +1229 i( + gg +-> +y +() == 0) + +1230 +v + = +r1 +. +g_lol +( +g +); + +1232 + gv + = +r1 +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1233 + gh +. +upde_cf +( +v +, (* +cvi +). +cf +); + +1237 +rtf +( +DebugFe +, "can't deal withhe variableype inower bound\n"); + +1238  + gd +:: +make_ +( +ic_ +< +CG_ouutRr + *>( +NULL +), +l +); + +1240 + gh +. +upde_cڡ +((* +gi +). +g_cڡ +()); + +1242 + gfound_mch + = +ue +; + +1249 i(! + gfound_mch +) + +1250 + gr1 +. +d_wh_EQ +(* +ei +); + +1252 i((* + gei +). +g_cf +( +v +) == 0) { + +1253 +Ri + +r3 + = Ri:: +True +( +b +. +n_t +()); + +1254 + gr3 +. +d_wh_EQ +(* +ei +); + +1255 +Ri + + gr4 + = +Gi +( +r3 +, +cy +( +fd +)); + +1256 i(! + gr4 +. +is_obvious_utogy +()) + +1257 + gr2 +. +d_wh_EQ +(* +ei +); + +1260 + gr2 +. +d_wh_EQ +(* +ei +); + +1265 + gd +:: +m +< +Vb_ID +, + gVb_ID +> + gexis_mpg +; + +1266 +F_Exis + * + g + = +r2 +. +d_wh_d +()-> +add_exis +(); + +1267 +F_And + * + gf_ro + = + +-> +add_d +(); + +1268  +GEQ_It + +gi +( +c +); + ggi +; gi++) { + +1269 +GEQ_Hd + + gh + = +f_ro +-> +add_GEQ +(); + +1270  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) { + +1271 +Vb_ID + + gv + = +cvi +. +cu_v +(); + +1272  + gv +-> +kd +()) { + +1273  + gIut_V +: { + +1274  +pos + = +v +-> +g_posi +(); + +1275 + gh +. +upde_cf +( +r2 +. +t_v +( +pos +), +cvi +. +cu_cf +()); + +1278  + gExis_V +: + +1279  +Wdrd_V +: { + +1280 +d +:: +m +< +Vb_ID +, + gVb_ID +>:: + + +p + = +exis_mpg +. +fd +( +v +); + +1281 +Vb_ID + + ge +; + +1282 i( + gp + = +exis_mpg +. +d +()) { + +1283 +e + = + +-> +dee +(); + +1284 + gexis_mpg +[ +v +] = +e +; + +1287 + ge + = (* +p +). +cd +; + +1288 + gh +. +upde_cf +( +e +, +cvi +. +cu_cf +()); + +1291  + gGlob_V +: { + +1292 +Glob_V_ID + +g + = +v +-> +g_glob_v +(); + +1293 +Vb_ID + + gv2 +; + +1294 i( + gg +-> +y +() == 0) + +1295 +v2 + = +r2 +. +g_lol +( +g +); + +1297 + gv2 + = +r2 +. +g_lol +( +g +, +v +-> +funi_of +()); + +1298 + gh +. +upde_cf +( +v2 +, +cvi +. +cu_cf +()); + +1302 +as +(0); + +1305 + gh +. +upde_cڡ +((* +gi +). +g_cڡ +()); + +1311 + gr1 +. +simify +(); + +1312 + gr2 +. +simify +(); + +1313 +Ri + + gb2 + = +Ii +( +r1 +, +r2 +); + +1314 + gb2 +. +simify +(); + +1315  + gi + = 1; i < +b +. +n_t +(); i++) + +1316 + gb2 +. +me_t_v +( +i +, +b +. +t_v +(i)-> +me +()); + +1317 + gb2 +. +tup_mes +(); + +1318 + gb + = +b2 +; + +1319 + gc + = +b +. +quy_DNF +()-> +sg_cjun +(); + +1324 +EQ_Hd + + grideEQ +; + +1325 +bo + + gfoundSide + = +l +; + +1326 +bo + + gfoundSimeSide + = +l +; + +1327 +cf_t + + g + = 1; + +1328  + gnum_ride + = 0; + +1330  +EQ_It + +ei +( +c +); + gei +;i++) { + +1331 i((* + gei +). +g_cf +( +v +!0 && (* +ei +). +has_wdrds +()) { + +1332 +num_ride +++; + +1334 i( +abs +((* +ei +). +g_cf +( +v +)) != 1) + +1337 +bo + + gt + = +ue +; + +1338 +cf_t + + gd + = 1; + +1339  +Cڡr_Vs_Ir + +cvi +(* +ei +); + gcvi +; cvi++) + +1340 i((* + gcvi +). + gv +-> +kd +(= +Wdrd_V +) { + +1341 +as +( +d +==1); + +1342 + gd + = +abs +((* +cvi +). +cf +); + +1344 i((* + gcvi +). + gv +-> +kd +(= +Iut_V +) { + +1345 i((* +cvi +). +v + ! +v +) + +1346 +t + = +l +; + +1349 + gt + = +l +; + +1351 i( + gd + > + g +) { + +1352 + g + = +d +; + +1353 + gfoundSimeSide + = +t +; + +1354 + grideEQ + = * +ei +; + +1355 + gfoundSide + = +ue +; + +1362 i(!( + gnum_ride + =0 || ( +num_ride + =1 && +foundSide +))) + +1363  +d +:: +make_ +( +ic_ +< +CG_ouutRr + *>( +NULL +), +l +); + +1366  + glow_bounds + = 0, + gu_bounds + = 0; + +1367 + gTue +< + gCG_ouutRr + *> + glbLi +; + +1368 + gTue +< + gCG_ouutRr + *> + gubLi +; + +1369 +cf_t + + gcڡ_lb + = +gInfy +, + gcڡ_ub + = +posInfy +; + +1370  +GEQ_It + +g +( +c +); + gg +; g++) { + +1371 +cf_t + + gcf + = (* +g +). +g_cf +( +v +); + +1372 i( + gcf + == 0) + +1374 i( + gcf + > 0) { + +1375 + glow_bounds +++; + +1376 i((* + gg +). +is_cڡ +( +v +&& ! + gfoundSide +) { + +1378 +cf_t + + gL +, + gm +; + +1379 + gL + = -((* +g +). +g_cڡ +()); + +1381 + gm + = (* +g +). +g_cf +( +v +); + +1382 +cf_t + + gsb + = (( + +((( +L +/ +m +)); + +1383 +t_max +( +cڡ_lb +, +sb +); + +1385 i((* + gg +). +is_cڡ +( +v +&& + gfoundSimeSide +) { + +1388 +cf_t + + gL +, + gm +, + gs +, + gc +; + +1389 + gL + = -((* +g +). +g_cڡ +()); + +1390 + gm + = (* +g +). +g_cf +( +v +); + +1391 + gs + = + +; + +1392 + gc + = +rideEQ +. +g_cڡ +(); + +1393 +cf_t + + gsb + = ( +s + * (( + +(( +L + - ( +c + * +m +)) /(s*m))))+ c; + +1394 +t_max +( +cڡ_lb +, +sb +); + +1397 + glbLi +. +nd +( +ouutLBasRr +( +ocg +, * +g +, +b +, +v +, + +, +rideEQ +, +fd +, +assigd__the_y +)); + +1400 + gu_bounds +++; + +1401 i((* + gg +). +is_cڡ +( +v +)) { + +1403 +t_m +( +cڡ_ub +,-(* +g +). +g_cڡ +()/(*g). +g_cf +( +v +)); + +1406 + gubLi +. +nd +( +ouutUBasRr +( +ocg +, * +g +, +b +, +v +, + +, +rideEQ +, +assigd__the_y +)); + +1410 +CG_ouutRr + * + glbRr + = +NULL +; + +1411 +CG_ouutRr + * + gubRr + = +NULL +; + +1412 i( + gcڡ_lb + ! +gInfy +) + +1413 +lbLi +. +nd +( +ocg +-> +CeI +( +cڡ_lb +)); + +1414 i( + glbLi +. +size +() > 1) + +1415 + glbRr + = +ocg +-> +CeInvoke +("max", +lbLi +); + +1416 i( + glbLi +. +size +() == 1) + +1417 +lbRr + = +lbLi +[1]; + +1420 if( + gflInBounds + && + glbLi +. +size +(=1 && +cڡ_lb + ! +gInfy +) + +1421 +lowBoundFLev + = +cڡ_lb +; + +1424 i( + gcڡ_ub + ! +posInfy +) + +1425 +ubLi +. +nd +( +ocg +-> +CeI +( +cڡ_ub +)); + +1426 i( + gubLi +. +size +() > 1) + +1427 + gubRr + = +ocg +-> +CeInvoke +("m", +ubLi +); + +1428 i( + gubLi +. +size +() == 1) + +1429 +ubRr + = +ubLi +[1]; + +1432 if( + gflInBounds + && + gcڡ_ub + ! +posInfy +) + +1433 +uBoundFLev + = +cڡ_ub +; + +1436 i( + gu_bounds + =0 || +low_bounds + == 0) { + +1437  +d +:: +make_ +( +ic_ +< +CG_ouutRr + *>( +NULL +), +l +); + +1441 +F_Exis + * + g + = +fd +. +d_wh_d +()-> +add_exis +(); + +1442 +F_And + * + gf_ro + = + +-> +add_d +(); + +1443 + gd +:: +m +< +Vb_ID +, + gVb_ID +> + gexis_mpg +; + +1444 + gd +:: +ack +< +d +:: + +< +GEQ_Hd +, + gVb_ID +> > + go_geq_ack +; + +1445 + gd +:: +t +< +Vb_ID +> +o_v_t +; + +1447 i( + gfoundSide +) { + +1448 +EQ_Hd + + gh + = +f_ro +-> +add_EQ +(); + +1449  +Cڡr_Vs_Ir + +cvi +( +rideEQ +); + gcvi +; cvi++) + +1450 (* + gcvi +). + gv +-> +kd +()) { + +1451  + gIut_V +: { + +1452  +pos + = (* +cvi +). +v +-> +g_posi +(); + +1453 + gh +. +upde_cf +( +fd +. +t_v +( +pos +), (* +cvi +). +cf +); + +1456  + gExis_V +: + +1457  +Wdrd_V +: { + +1458 +d +:: +m +< +Vb_ID +, + gVb_ID +>:: + + +p + = +exis_mpg +. +fd +((* +cvi +). +v +); + +1459 +Vb_ID + + ge +; + +1460 i( + gp + = +exis_mpg +. +d +()) { + +1461 +e + = + +-> +dee +(); + +1462 + gexis_mpg +[(* +cvi +). +v +] = +e +; + +1465 + ge + = (* +p +). +cd +; + +1466 + gh +. +upde_cf +( +e +, (* +cvi +). +cf +); + +1469  + gGlob_V +: { + +1470 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +1471 +Vb_ID + + ge +; + +1472 i( + gg +-> +y +() == 0) + +1473 +e + = +fd +. +g_lol +( +g +); + +1475 + ge + = +fd +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1476 + gh +. +upde_cf +( +e +, (* +cvi +). +cf +); + +1480 +as +(0); + +1482 + gh +. +upde_cڡ +( +rideEQ +. +g_cڡ +()); + +1485  +GEQ_It + +gi +( +c +); + ggi +; gi++) + +1486 i((* + ggi +). +g_cf +( +v +) != 0) { + +1487 +GEQ_Hd + +h + = +f_ro +-> +add_GEQ +(); + +1488  +Cڡr_Vs_Ir + +cvi +(* +gi +); + gcvi +; cvi++) + +1489 (* + gcvi +). + gv +-> +kd +()) { + +1490  + gIut_V +: { + +1491  +pos + = (* +cvi +). +v +-> +g_posi +(); + +1492 + gh +. +upde_cf +( +fd +. +t_v +( +pos +), (* +cvi +). +cf +); + +1495  + gExis_V +: + +1496  +Wdrd_V +: { + +1497 +d +:: +m +< +Vb_ID +, + gVb_ID +>:: + + +p + = +exis_mpg +. +fd +((* +cvi +). +v +); + +1498 +Vb_ID + + ge +; + +1499 i( + gp + = +exis_mpg +. +d +()) { + +1500 +e + = + +-> +dee +(); + +1501 + gexis_mpg +[(* +cvi +). +v +] = +e +; + +1504 + ge + = (* +p +). +cd +; + +1505 + gh +. +upde_cf +( +e +, (* +cvi +). +cf +); + +1507 i( + go_v_t +. +fd +((* +cvi +). +v += +o_v_t +. +d +()) { + +1508 +GEQ_Hd + +h2 +; + +1509 +fdFloIquy +( +b +, (* +cvi +). +v +, +h2 +, +v +); + +1510 + go_geq_ack +. +push +( +d +:: +make_ +( +h2 +, (* +cvi +). +v +)); + +1511 + go_v_t +. + +((* +cvi +). +v +); + +1515  + gGlob_V +: { + +1516 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +1517 +Vb_ID + + ge +; + +1518 i( + gg +-> +y +() == 0) + +1519 +e + = +fd +. +g_lol +( +g +); + +1521 + ge + = +fd +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1522 + gh +. +upde_cf +( +e +, (* +cvi +). +cf +); + +1526 +as +(0); + +1528 + gh +. +upde_cڡ +((* +gi +). +g_cڡ +()); + +1532 ! + go_geq_ack +. +emy +()) { + +1533 + gd +:: + +< +GEQ_Hd +, + gVb_ID +> + gp + = +o_geq_ack +. +t +(); + +1534 + go_geq_ack +. +p +(); + +1536 +GEQ_Hd + + gh1 + = +f_ro +-> +add_GEQ +(); + +1537 +GEQ_Hd + + gh2 + = +f_ro +-> +add_GEQ +(); + +1538  +Cڡr_Vs_Ir + +cvi +( +p +. +f +); + gcvi +; cvi++) { + +1539 (* + gcvi +). + gv +-> +kd +()) { + +1540  + gIut_V +: { + +1541  +pos + = (* +cvi +). +v +-> +g_posi +(); + +1542 + gh1 +. +upde_cf +( +fd +. +put_v +( +pos +), (* +cvi +). +cf +); + +1543 + gh2 +. +upde_cf +( +fd +. +put_v +( +pos +), -(* +cvi +). +cf +); + +1546  + gExis_V +: + +1547  +Wdrd_V +: { + +1548 +d +:: +m +< +Vb_ID +, + gVb_ID +>:: + + +p2 + = +exis_mpg +. +fd +((* +cvi +). +v +); + +1549 +Vb_ID + + ge +; + +1550 i( + gp2 + = +exis_mpg +. +d +()) { + +1551 +e + = + +-> +dee +(); + +1552 + gexis_mpg +[(* +cvi +). +v +] = +e +; + +1555 + ge + = (* +p2 +). +cd +; + +1556 + gh1 +. +upde_cf +( +e +, (* +cvi +). +cf +); + +1557 + gh2 +. +upde_cf +( +e +, -(* +cvi +). +cf +); + +1559 i( + go_v_t +. +fd +((* +cvi +). +v += +o_v_t +. +d +()) { + +1560 +GEQ_Hd + +h3 +; + +1561 +fdFloIquy +( +b +, (* +cvi +). +v +, +h3 +, +v +); + +1562 + go_geq_ack +. +push +( +d +:: +make_ +( +h3 +, (* +cvi +). +v +)); + +1563 + go_v_t +. + +((* +cvi +). +v +); + +1567  + gGlob_V +: { + +1568 +Glob_V_ID + +g + = (* +cvi +). +v +-> +g_glob_v +(); + +1569 +Vb_ID + + ge +; + +1570 i( + gg +-> +y +() == 0) + +1571 +e + = +fd +. +g_lol +( +g +); + +1573 + ge + = +fd +. +g_lol +( +g +, (* +cvi +). +v +-> +funi_of +()); + +1574 + gh1 +. +upde_cf +( +e +, (* +cvi +). +cf +); + +1575 + gh2 +. +upde_cf +( +e +, -(* +cvi +). +cf +); + +1579 +as +(0); + +1582 + gh1 +. +upde_cڡ +( +p +. +f +. +g_cڡ +()); + +1583 + gh2 +. +upde_cڡ +(- +p +. +f +. +g_cڡ +()); + +1584 + gh2 +. +upde_cڡ +(- +p +. +f +. +g_cf +. +cd +)-1); + +1586 + gfd +. +simify +(); + +1588 +CG_ouutRr + * + gRr + = +NULL +; + +1589 i( + g + != 1) + +1590 +Rr + = +ocg +-> +CeI +( +abs +( + +)); + +1591 +CG_ouutRr + * + gdexRr + = +ouutIdt +( +ocg +, +b +, +v +, +assigd__the_y +); + +1592 +CG_ouutRr + * + gRr + = +ocg +-> +CeInduive +( +dexRr +, +lbRr +, +ubRr +, +Rr +); + +1594  + gd +:: +make_ +( +Rr +, +ue +); + +1599 +Ri + +oje_to_vs +(Ri +R +,  +ϡ_v +, +bo + +wdrds +) { + +1600 +as +( +ϡ_v + >0 && +R +. +is_t +(&&a_v +dee +(); + +1639 +F_And + * + ga + = +e +-> +add_d +(); + +1640 +EQ_Hd + + gh + = +a +-> +add_EQ +(); + +1641  +Cڡr_Vs_Ir + +I +( +g +, +l +); + gI +; I++) + +1642 if((* + gI +). + gv + ! +v +) { + +1643 if((* +I +). +v +-> +kd +(! +Glob_V +) + +1644 +h +. +upde_cf +((* +I +). +v +, (*I). +cf +); + +1646 + gh +. +upde_cf +( + +. +g_lol +((* +I +). +v +-> +g_glob_v +()), (*I). +cf +); + +1649 + gh +. +upde_cڡ +( +g +. +g_cڡ +()); + +1650 + gh +. +upde_cf +( +pha +, +m +); + +1651 i(!( +Gi +( + +, +cy +( +known +)). +is_obvious_utogy +())) + +1652  + gl +; + +1654 +Ri + + gboundR + = +known +; + +1655 + gboundR +. +d_wh_EQ +( +g +); + +1656 +Ri + +rideR +( +known +. +n_t +()); + +1657 + grideR +. +d_wh_EQ +( +rideEQ +); + +1658  +Gi +( +rideR +, +boundR +). +is_obvious_utogy +(); + +1663 +bo + +isSimeSide +(cڡ +EQ_Hd + & +g +, +Vb_ID + +v +) { + +1664 +EQ_Hd + + ggg + = +g +; + +1666 +bo + + gis_sime += +ue +; + +1667  +Cڡr_Vs_Ir + +cvi +( +gg +, +l +); + gcvi + && + gis_sime +; cvi++) + +1668 + gis_sime + = ((* +cvi +). +cf + =0 || (*cvi). +v + = +v + + +1669 || (* +cvi +). +v +-> +kd +(= +Wdrd_V +); + +1670  + gis_sime +; + +1674  +couSides +( +Cjun + * +c +, +Vb_ID + +v +, +EQ_Hd + & +rideEQ +, + +1675 +bo + & +sime +) { + +1676  + grides +=0; + +1677  +EQ_It + +G +( +c +); + gG +; G++) + +1678  +Cڡr_Vs_Ir + +I +(* +G +, +ue +); + gI +; I++) + +1679 i(((* + gI +). + gcf + !0&& (* +G +). +g_cf +( +v +) != 0) { + +1680 +rides +++; + +1681 + gsime + = +isSimeSide +(* +G +, +v +); + +1682 + grideEQ + = * +G +; + +1685  + grides +; + +1688 + gmea + { + +1690 +bo + +hasEQ +( +Ri + +r +,  +v +) { + +1691 + gr +. +simify +(); + +1692 +Vb_ID + + gv + = +t_v +( +v +); + +1693 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1694  +EQ_It + +G +( +s_cj +); + gG +; G++) + +1695 i((* + gG +). +g_cf +( +v +)) + +1696  + gue +; + +1697  + gl +; + +1702  +Ri + +pickEQ +(Ri +r +,  +v +) { + +1703 + gr +. +simify +(); + +1704 +Vb_ID + + gv + = +t_v +( +v +); + +1705 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1706  +EQ_It + +E +( +s_cj +); + gE +; E++) + +1707 i((* + gE +). +g_cf +( +v +)) { + +1708 +Ri + +_l +( +r +. +n_t +()); + +1709 + g_l +. +d_wh_EQ +(* +E +); + +1710  + g_l +; + +1712 +as +(0); + +1713  + gr +; + +1717 +Ri + +pickBound +(Ri +r +,  +v +,  +UB +) { + +1718 + gr +. +simify +(); + +1719 +Vb_ID + + gv + = +t_v +( +v +); + +1720 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1721  +GEQ_It + +G +( +s_cj +); + gG +; G++) { + +1722 i(( + gUB + && (* + gG +). +g_cf +( +v +) < 0) + +1723 || (! + gUB + && (* + gG +). +g_cf +( +v +) > 0) ) { + +1724 +Ri + +_l +( +r +. +n_t +()); + +1725 + g_l +. +d_wh_GEQ +(* +G +); + +1726  + g_l +; + +1729  +EQ_It + +E +( +s_cj +); + gE +; E++) { + +1730 i((* + gE +). +g_cf +( +v +)) { + +1731 +Ri + +_l +( +r +. +n_t +()); + +1732 + g_l +. +d_wh_GEQ +(* +E +); + +1733 i(( + gUB + && (* + gE +). +g_cf +( +v +) > 0) + +1734 || (! + gUB + && (* + gE +). +g_cf +( +v +) < 0) ) + +1735 + g_l + = +Comemt +( +_l +); + +1736  + g_l +; + +1739 +as +(0); + +1740  + gr +; + +1745 +Ri + +pickOvhd +(Ri +r +,  +liTo +) { + +1746 + gr +. +simify +(); + +1747 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1748  +GEQ_It + +G +( +s_cj +); + gG +; G++) { + +1749 +Ri + +_l +( +r +. +n_t +()); + +1750 + g_l +. +d_wh_GEQ +(* +G +); + +1751 +Vb_ID + + gv +; + +1752 +cf_t + + gpos + = -1; + +1753 +cf_t + + gc += 0; + +1754  +Cڡr_Vs_Ir + +cvi +(* +G +, +l +); + gcvi +; cvi++) + +1755 i((* + gcvi +). + gcf + && (*cvi). + gv +-> +kd +(= +Iut_V + + +1756 && (* +cvi +). +v +-> +g_posi +(> +pos +) { + +1757 +v + = (* +cvi +). +v +; + +1758 + gpos + = (* +cvi +). +v +-> +g_posi +(); + +1759 + gc + = (* +cvi +). +cf +; + +1762 +rtf +( +DebugFe +,"Coef = %d, constraint = %s\n", + +1763 +c +,(cڡ *) +_l +. +t_fmu_to_rg +()); + +1765  + g_l +; + +1767  +EQ_It + +E +( +s_cj +); + gE +; E++) { + +1768 +as +( +liTo + >= 1); + +1769  + gpos + = +max +((* +E +). +max_tue_pos +(), +max_fs_y +(*E)+1); + +1773 i((* + gE +). +has_wdrds +(&& + gpos + < + gliTo +) { + +1774 +Ri + +_l +( +r +. +n_t +()); + +1775 + g_l +. +d_wh_EQ +(* +E +); + +1776  + g_l +; + +1778 i(!(* + gE +). +has_wdrds +(&& + gpos + < +liTo +) { + +1779 +Ri + +_l +( +r +. +n_t +()); + +1780 + g_l +. +d_wh_EQ +(* +E +); + +1781 + g_l +. +simify +(); + +1782 + g_l + = +EQs_to_GEQs +( +_l +, +ue +); + +1783  +pickOvhd +( +_l +, +liTo +); + +1786 i( + gcode_g_debug +>1) { + +1787 +rtf +( +DebugFe +,"Couldot find overhead:\n"); + +1788 + gr +. +efix_t +( +DebugFe +); + +1790  + gRi +:: +True +( +r +. +n_t +()); + +1795 +bo + +hasBound +( +Ri + +r +,  +v +,  +UB +) { + +1796 + gr +. +simify +(); + +1797 +Vb_ID + + gv + = +t_v +( +v +); + +1798 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1799  +GEQ_It + +G +( +s_cj +); + gG +; G++) { + +1800 i( + gUB + && (* + gG +). +g_cf +( +v +< 0 + gue +; + +1801 i(! + gUB + && (* + gG +). +g_cf +( +v +> 0 + gue +; + +1803  +EQ_It + +E +( +s_cj +); + gE +; E++) { + +1804 i((* + gE +). +g_cf +( +v +) + gue +; + +1806  + gl +; + +1809 +bo + +fd_y_cڡt +( +s +,  +v +, +Ri + & +kr +,  +dei +, + +1810 +Ri + & +S +, +bo + +ox +) { + +1816 +Ri + + gI + = +ojeed_nIS +[ +v +][ +s +]; + +1817 + gI + = +Gi +( +I +, +cy +( +kr +)); + +1818 if( + gox + + gI + = +Aroxime +( +I +); + +1819 i( +hasBound +( +I +, +v +, +dei +)) { + +1820 +Ri + + gpickom +; + +1821 if( +has_nڡride_EQ +( +I +, +v +)) + +1822 + gpickom + = +pickEQ +( +I +, +v +); + +1824 + gpickom + = +pickBound +( +I +, +v +, +dei +); + +1825 + gS + = +pickOvhd +( +pickom +, +v +); + +1826 if( + gS +. +is_obvious_utogy +()S = +Ri +:: +Nu +(); + +1827  ! + gS +. +is_nu +(); + +1829  + gl +; + +1833 +bo + +has_nڡride_EQ +( +Ri + +r +,  +v +) { + +1834 + gr +. +simify +(); + +1835 +Vb_ID + + gv + = +t_v +( +v +); + +1836 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1837  +EQ_It + +G +( +s_cj +); + gG +; G++) + +1838 i((* + gG +). +g_cf +( +v +&& !(*G). +has_wdrds +()) + +1839  + gue +; + +1840  + gl +; + +1844 +Ri + +mMaxOvhd +(Ri +r +,  +v +) { + +1845 + gr +. +fize +(); + +1846 + gr +. +simify +(); + +1847 +Cjun + * + gs_cj + = +r +. +sg_cjun +(); + +1848 +GEQ_Hd + + gLBs +[50], + gUBs +[50]; + +1849  + gnumLBs + = 0; + +1850  + gnumUBs + = 0; + +1851 +Vb_ID + + gv + = +t_v +( +v +); + +1852  +GEQ_It + +G +( +s_cj +); + gG +; G++i((*G). +g_cf +( +v +)) { + +1853 +GEQ_Hd + + gg + = * +G +; + +1854 i( + gg +. +g_cf +( +v +> 0 + gLBs +[ +numLBs +++] = +g +; + +1855 + gUBs +[ +numUBs +++] = +g +; + +1857 i( + gnumLBs + <1 && +numUBs + <= 1) { + +1858  +Ri +:: +True +( +r +. +n_t +()); + +1860 +Ri + +r1 +( +r +. +n_t +()); + +1861 +Ri + +r2 +( +r +. +n_t +()); + +1862 i( + gnumLBs + > 1) { + +1864 + gr1 +. +d_wh_GEQ +( +LBs +[0]); + +1865 + gr2 +. +d_wh_GEQ +( +LBs +[1]); + +1866 + gr1 + = +oje_to_vs +( +Difn +( +r1 +, +r2 +), +v +-1,0); + +1870 + gr1 +. +d_wh_GEQ +( +UBs +[0]); + +1871 + gr2 +. +d_wh_GEQ +( +UBs +[1]); + +1872 + gr1 + = +oje_to_vs +( +Difn +( +r1 +, +r2 +), +v +-1,0); + +1875 +rtf +( +DebugFe +,"Teg %s\n",(cڡ *) +r1 +. +t_fmu_to_rg +()); + +1876 +rtf +( +DebugFe +,"wȻmoved ovhd oboundot%d: %s\n", +v +, + +1877 (cڡ *) +r +. +t_fmu_to_rg +()); + +1880  +pickOvhd +( +r1 +, -1); + +1883 + gd +:: + +< +EQ_Hd +, > +fd_sime_assignmt +(cڡ +Ri + & +R_ +, +Vb_ID + +v +, cڡ +d +:: +ve +< +CG_ouutRr + *> & +assigd__the_y +) { + +1884 +Ri + & +R + = +cڡ_ +( +R_ +); + +1885 +Cjun + * + gc + = +R +. +sg_cjun +(); + +1887  + gm_co + = +INT_MAX +; + +1888 +EQ_Hd + + geq +; + +1889  +EQ_It + +ei +( +c +-> +EQs +()); + gei +;i++) + +1890 i(!(* + gei +). +has_wdrds +(&& (*ei). +g_cf +( +v +) != 0) { + +1891  +co + = 0; + +1893 i( +abs +((* +ei +). +g_cf +( +v +)) != 1) + +1894 +co + += 4; + +1896  + gnum_v + = 0; + +1897  +Cڡr_Vs_Ir + +cvi +(* +ei +); + gcvi +; cvi++) + +1898 i((* + gcvi +). + gv + ! +v +) { + +1899 +num_v +++; + +1900 i((* + gcvi +). + gv +-> +kd +(= +Glob_V + && (* +cvi +). +v +-> +g_glob_v +()-> +y +() > 0) { + +1901 +co + += 10; + +1903 i( +abs +((* +cvi +). +cf +) != 1) + +1904 +co + += 2; + +1905 i((* + gcvi +). + gv +-> +kd +(= +Iut_V + && +assigd__the_y +[(* +cvi +). +v +-> +g_posi +()-1] ! +NULL +) { + +1906 +co + += 5; + +1909 i((* + gei +). +g_cڡ +() != 0) + +1910 +num_v +++; + +1911 i( + gnum_v + > 1) + +1912 + gco + + +num_v + - 1; + +1914 i( + gco + < + gm_co +) { + +1915 + gm_co + = +co +; + +1916 + geq + = * +ei +; + +1920  + gd +:: +make_ +( +eq +, +m_co +); + +1923  +max_fs_y +(cڡ +Cڡt_Hd + & +c +) { + +1924  + gmax_y +=0; + +1925  +Cڡr_Vs_Ir + +cv +( +c +); + gcv +; cv++) + +1926 if((* + gcv +). + gv +-> +kd +(= +Glob_V +) + +1927 +max_y + = +max +(max_y,(* +cv +). +v +-> +g_glob_v +()-> +y +()); + +1928  + gmax_y +; + + @/usr/include/math.h + +25 #idef +_MATH_H + + +26  + #_MATH_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +34  + ~ + +35 #ifde +__USE_ISOC99 + + +36  + ~ + +37  + ~ + +40  + ~ + +43  + ~ + +47  + ~ + +54  + #__MATHCALL +( +funi +, +suffix +, +gs +) \ + +55 + `__MATHDECL + ( +_Mdoub_ +, +funi +, +suffix +, +gs +) + + ) + +56  + #__MATHDECL +( +ty +, +funi +, +suffix +, +gs +) \ + +57 + `__MATHDECL_1 +( +ty +, +funi +, +suffix +, +gs +); \ + +58 + `__MATHDECL_1 +( +ty +, + `__CONCAT +( +__ +, +funi +), +suffix +, +gs +) + + ) + +59  + #__MATHCALLX +( +funi +, +suffix +, +gs +, +ib +) \ + +60 + `__MATHDECLX + ( +_Mdoub_ +, +funi +, +suffix +, +gs +, +ib +) + + ) + +61  + #__MATHDECLX +( +ty +, +funi +, +suffix +, +gs +, +ib +) \ + +62 + `__MATHDECL_1 +( +ty +, +funi +, +suffix +, +gs + + `__ibu__ + ( +ib +); \ + +63 + `__MATHDECL_1 +( +ty +, + `__CONCAT +( +__ +, +funi +), +suffix +, +gs + + `__ibu__ + ( +ib +) + + ) + +64  + #__MATHDECL_1 +( +ty +, +funi +, +suffix +, +gs +) \ + +65 +ty + + `__MATH_PRECNAME +( +funi +, +suffix + +gs + +__THROW + + + ) + +67  + #_Mdoub_ +  + + ) + +68  + #__MATH_PRECNAME +( +me +, +r + + `__CONCAT +ame,r) + + ) + +69  + #_Mdoub_BEGIN_NAMESPACE + +__BEGIN_NAMESPACE_STD + + + ) + +70  + #_Mdoub_END_NAMESPACE + +__END_NAMESPACE_STD + + + ) + +71  + ~ + +72 #unde +_Mdoub_ + + +73 #unde +_Mdoub_BEGIN_NAMESPACE + + +74 #unde +_Mdoub_END_NAMESPACE + + +75 #unde +__MATH_PRECNAME + + +77 #i +defed + +__USE_MISC + || defed +__USE_ISOC99 + + +83 #ide +_Mt_ + + +84  + #_Mt_ +  + + ) + +86  + #_Mdoub_ + +_Mt_ + + + ) + +87 #ifde +__STDC__ + + +88  + #__MATH_PRECNAME +( +me +, +r +me## +f +## + ) +r + +90  + #__MATH_PRECNAME +( +me +, +r +m +f + + ) +r + +92  + #_Mdoub_BEGIN_NAMESPACE + +__BEGIN_NAMESPACE_C99 + + + ) + +93  + #_Mdoub_END_NAMESPACE + +__END_NAMESPACE_C99 + + + ) + +94  + ~ + +95 #unde +_Mdoub_ + + +96 #unde +_Mdoub_BEGIN_NAMESPACE + + +97 #unde +_Mdoub_END_NAMESPACE + + +98 #unde +__MATH_PRECNAME + + +100 #i( +__STDC__ + - 0 || +__GNUC__ + - 0) \ + +101 && (! +defed + +__NO_LONG_DOUBLE_MATH + \ + +102 || +defed + +__LDBL_COMPAT + \ + +103 || ! +defed + +_LIBC +) + +104 #ifde +__LDBL_COMPAT + + +106 #ifde +__USE_ISOC99 + + +107  + $__dbl_xowdf + ( +__x +,  +__y +) + +108 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +109 #ifde +__REDIRECT_NTH + + +110  + `__REDIRECT_NTH + ( +xowdf +, ( +__x +,  +__y +), + +111 +__dbl_xowdf +) + +112 + `__ibu__ + (( +__cڡ__ +)); + +113  + `__REDIRECT_NTH + ( +xowd +, ( +__x +,  +__y +), + +114 +x + + `__ibu__ + (( +__cڡ__ +)); + +115  + `__REDIRECT_NTH + ( +xowdl +, + +116 ( +__x +,  +__y +), + +117 +x + + `__ibu__ + (( +__cڡ__ +)); + +122 #i +defed + +__LDBL_COMPAT + || defed +__NO_LONG_DOUBLE_MATH + + +124 #unde +__MATHDECL_1 + + +125  + #__MATHDECL_2 +( +ty +, +funi +, +suffix +, +gs +, +s +) \ + +126 +ty + + `__REDIRECT_NTH +( + `__MATH_PRECNAME +( +funi +, +suffix +), \ + +127 +gs +, +s +) + + ) + +128  + #__MATHDECL_1 +( +ty +, +funi +, +suffix +, +gs +) \ + +129 + `__MATHDECL_2 +( +ty +, +funi +, +suffix +, +gs +, + `__CONCAT +(funi,suffix)) + + ) + +134 #ide +_Mlg_doub_ + + +135  + #_Mlg_doub_ +  + + ) + +137  + #_Mdoub_ + +_Mlg_doub_ + + + ) + +138 #ifde +__STDC__ + + +139  + #__MATH_PRECNAME +( +me +, +r +me## +l +## + ) +r + +141  + #__MATH_PRECNAME +( +me +, +r +m +l + + ) +r + +143  + #_Mdoub_BEGIN_NAMESPACE + +__BEGIN_NAMESPACE_C99 + + + ) + +144  + #_Mdoub_END_NAMESPACE + +__END_NAMESPACE_C99 + + + ) + +145  + ~ + +146 #unde +_Mdoub_ + + +147 #unde +_Mdoub_BEGIN_NAMESPACE + + +148 #unde +_Mdoub_END_NAMESPACE + + +149 #unde +__MATH_PRECNAME + + +154 #unde +__MATHDECL_1 + + +155 #unde +__MATHDECL + + +156 #unde +__MATHCALL + + +159 #i +defed + +__USE_MISC + || defed +__USE_XOPEN + + +161  +signgam +; + +166 #ifde +__USE_ISOC99 + + +204 +FP_NAN +, + +205  + #FP_NAN + +FP_NAN + + + ) + +206 +FP_INFINITE +, + +207  + #FP_INFINITE + +FP_INFINITE + + + ) + +208 +FP_ZERO +, + +209  + #FP_ZERO + +FP_ZERO + + + ) + +210 +FP_SUBNORMAL +, + +211  + #FP_SUBNORMAL + +FP_SUBNORMAL + + + ) + +212 +FP_NORMAL + + +213  + #FP_NORMAL + +FP_NORMAL + + + ) + +217 #ifde +__NO_LONG_DOUBLE_MATH + + +218  + #assify +( +x +) \ + +219 ( ( +x += (? + `__assifyf + (x: + `__assify + (x)) + + ) + +221  + #assify +( +x +) \ + +222 ( ( +x +) ==  () \ + +223 ? + `__assifyf + ( +x +) \ + +224 :  ( +x +) ==  () \ + +225 ? + `__assify + ( +x +: + `__assifyl + (x)) + + ) + +229 #ifde +__NO_LONG_DOUBLE_MATH + + +230  + #signb +( +x +) \ + +231 ( ( +x += (? + `__signbf + (x: + `__signb + (x)) + + ) + +233  + #signb +( +x +) \ + +234 ( ( +x +) ==  () \ + +235 ? + `__signbf + ( +x +) \ + +236 :  ( +x +) ==  () \ + +237 ? + `__signb + ( +x +: + `__signbl + (x)) + + ) + +241 #ifde +__NO_LONG_DOUBLE_MATH + + +242  + #isfe +( +x +) \ + +243 ( ( +x += (? + `__fef + (x: + `__fe + (x)) + + ) + +245  + #isfe +( +x +) \ + +246 ( ( +x +) ==  () \ + +247 ? + `__fef + ( +x +) \ + +248 :  ( +x +) ==  () \ + +249 ? + `__fe + ( +x +: + `__f + (x)) + + ) + +253  + #im +( +x +( + `assify + (x= +FP_NORMAL +) + + ) + +257 #ifde +__NO_LONG_DOUBLE_MATH + + +258  + #i +( +x +) \ + +259 ( ( +x += (? + `__if + (x: + `__i + (x)) + + ) + +261  + #i +( +x +) \ + +262 ( ( +x +) ==  () \ + +263 ? + `__if + ( +x +) \ + +264 :  ( +x +) ==  () \ + +265 ? + `__i + ( +x +: + `__il + (x)) + + ) + +269 #ifde +__NO_LONG_DOUBLE_MATH + + +270  + #isf +( +x +) \ + +271 ( ( +x += (? + `__isff + (x: + `__isf + (x)) + + ) + +273  + #isf +( +x +) \ + +274 ( ( +x +) ==  () \ + +275 ? + `__isff + ( +x +) \ + +276 :  ( +x +) ==  () \ + +277 ? + `__isf + ( +x +: + `__is + (x)) + + ) + +281  + #MATH_ERRNO + 1 + + ) + +282  + #MATH_ERREXCEPT + 2 + + ) + +287 #ide +__FAST_MATH__ + + +288  + #mh_rhdlg + ( +MATH_ERRNO + | +MATH_ERREXCEPT +) + + ) + +293 #ifdef +__USE_MISC + + +297 +_IEEE_ + = -1, + +298 +_SVID_ +, + +299 +_XOPEN_ +, + +300 +_POSIX_ +, + +301 +_ISOC_ + + +302 } + t_LIB_VERSION_TYPE +; + +307 +_LIB_VERSION_TYPE + +_LIB_VERSION +; + +311 #ifde +__USE_SVID + + +317 #ifde +__lulus + + +318  +__exi + + +320  +exi + + +323  +ty +; + +324 * +me +; + +325  +g1 +; + +326  +g2 +; + +327  +tv +; + +328 + } +}; + +330 #ifde +__lulus + + +331  + $mhr + ( +__exi + * +__exc + + `throw + (); + +333  + `mhr + ( +exi + * +__exc +); + +336  + #X_TLOSS + 1.41484755040568800000e+16 + + ) + +339  + #DOMAIN + 1 + + ) + +340  + #SING + 2 + + ) + +341  + #OVERFLOW + 3 + + ) + +342  + #UNDERFLOW + 4 + + ) + +343  + #TLOSS + 5 + + ) + +344  + #PLOSS + 6 + + ) + +347  + #HUGE + 3.40282347e+38F + + ) + +351 #ifde +__USE_XOPEN + + +353  + #MAXFLOAT + 3.40282347e+38F + + ) + +360 #i +defed + +__USE_BSD + || defed +__USE_XOPEN + + +361  + #M_E + 2.7182818284590452354 + + ) + +362  + #M_LOG2E + 1.4426950408889634074 + + ) + +363  + #M_LOG10E + 0.43429448190325182765 + + ) + +364  + #M_LN2 + 0.69314718055994530942 + + ) + +365  + #M_LN10 + 2.30258509299404568402 + + ) + +366  + #M_PI + 3.14159265358979323846 + + ) + +367  + #M_PI_2 + 1.57079632679489661923 + + ) + +368  + #M_PI_4 + 0.78539816339744830962 + + ) + +369  + #M_1_PI + 0.31830988618379067154 + + ) + +370  + #M_2_PI + 0.63661977236758134308 + + ) + +371  + #M_2_SQRTPI + 1.12837916709551257390 + + ) + +372  + #M_SQRT2 + 1.41421356237309504880 + + ) + +373  + #M_SQRT1_2 + 0.70710678118654752440 + + ) + +379 #ifde +__USE_GNU + + +380  + #M_El + 2.7182818284590452353602874713526625L + + ) + +381  + #M_LOG2El + 1.4426950408889634073599246810018921L + + ) + +382  + #M_LOG10El + 0.4342944819032518276511289189166051L + + ) + +383  + #M_LN2l + 0.6931471805599453094172321214581766L + + ) + +384  + #M_LN10l + 2.3025850929940456840179914546843642L + + ) + +385  + #M_PIl + 3.1415926535897932384626433832795029L + + ) + +386  + #M_PI_2l + 1.5707963267948966192313216916397514L + + ) + +387  + #M_PI_4l + 0.7853981633974483096156608458198757L + + ) + +388  + #M_1_PIl + 0.3183098861837906715377675267450287L + + ) + +389  + #M_2_PIl + 0.6366197723675813430755350534900574L + + ) + +390  + #M_2_SQRTPIl + 1.1283791670955125738961589031215452L + + ) + +391  + #M_SQRT2l + 1.4142135623730950488016887242096981L + + ) + +392  + #M_SQRT1_2l + 0.7071067811865475244008443621048490L + + ) + +399 #i +defed + +__STRICT_ANSI__ + && !defed +__NO_MATH_INLINES + + +400  + #__NO_MATH_INLINES + 1 + + ) + +403 #i +defed + +__USE_ISOC99 + && + `__GNUC_PREREQ +(2,97) + +410  + #isg +( +x +, +y + + `__but_isg +(x, y) + + ) + +411  + #isgequ +( +x +, +y + + `__but_isgequ +(x, y) + + ) + +412  + #iess +( +x +, +y + + `__but_iess +(x, y) + + ) + +413  + #iesqu +( +x +, +y + + `__but_iesqu +(x, y) + + ) + +414  + #iessg +( +x +, +y + + `__but_iessg +(x, y) + + ) + +415  + #isunded +( +u +, +v + + `__but_isunded +(u, v) + + ) + +419 #ifde +__USE_EXTERN_INLINES + + +420  + ~ + +423 #ifde +__USE_ISOC99 + + +427 #ide +isg + + +428  + #isg +( +x +, +y +) \ + +429 ( +__exnsi__ + \ + +430 ({ + `__tyof__ +( +x + +__x + = (x); __tyof__( +y + +__y + = (y); \ + +431 ! + `isunded + ( +__x +, +__y +&& __x > __y; + } +})) + + ) + +435 #ide +isgequ + + +436  + #isgequ +( +x +, +y +) \ + +437 ( +__exnsi__ + \ + +438 ({ + `__tyof__ +( +x + +__x + = (x); __tyof__( +y + +__y + = (y); \ + +439 ! + `isunded + ( +__x +, +__y +&& __x >__y; })) + + ) + +443 #ide +iess + + +444  + #iess +( +x +, +y +) \ + +445 ( +__exnsi__ + \ + +446 ({ + `__tyof__ +( +x + +__x + = (x); __tyof__( +y + +__y + = (y); \ + +447 ! + `isunded + ( +__x +, +__y +&& __x < __y; })) + + ) + +451 #ide +iesqu + + +452  + #iesqu +( +x +, +y +) \ + +453 ( +__exnsi__ + \ + +454 ({ + `__tyof__ +( +x + +__x + = (x); __tyof__( +y + +__y + = (y); \ + +455 ! + `isunded + ( +__x +, +__y +&& __x <__y; })) + + ) + +459 #ide +iessg + + +460  + #iessg +( +x +, +y +) \ + +461 ( +__exnsi__ + \ + +462 ({ + `__tyof__ +( +x + +__x + = (x); __tyof__( +y + +__y + = (y); \ + +463 ! + `isunded + ( +__x +, +__y +&& (__x < __y || __y < __x); })) + + ) + +467 #ide +isunded + + +468  + #isunded +( +u +, +v +) \ + +469 ( +__exnsi__ + \ + +470 ({ + `__tyof__ +( +u + +__u + = (u); __tyof__( +v + +__v + = (v); \ + +471 + `assify + ( +__u += +FP_NAN + || fpassify ( +__v +=FP_NAN; })) + + ) + +476 + g__END_DECLS + + + @/usr/include/stdio.h + +24 #ide +_STDIO_H + + +26 #i! +defed + +__ed_FILE + && !defed +__ed___FILE + + +27  + #_STDIO_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +32  + #__ed_size_t + + + ) + +33  + #__ed_NULL + + + ) + +34  + ~ + +36  + ~ + +37  + #__ed_FILE + + + ) + +38  + #__ed___FILE + + + ) + +42 #i! +defed + +__FILE_defed + && defed +__ed_FILE + + +45  + g_IO_FILE +; + +47 +__BEGIN_NAMESPACE_STD + + +49  +_IO_FILE + + tFILE +; + +50 + g__END_NAMESPACE_STD + + +51 #i +defed + +__USE_LARGEFILE64 + || defed +__USE_SVID + || defed +__USE_POSIX + \ + +52 || +defed + + g__USE_BSD + || defed + g__USE_ISOC99 + || defed + g__USE_XOPEN + \ + +53 || +defed + +__USE_POSIX2 + + +54 + $__USING_NAMESPACE_STD +( +FILE +) + +57  + #__FILE_defed + 1 + + ) + +59 #unde +__ed_FILE + + +62 #i! +defed + +____FILE_defed + && defed +__ed___FILE + + +65  +_IO_FILE + + t__FILE +; + +67  + #____FILE_defed + 1 + + ) + +69 #unde +__ed___FILE + + +72 #ifdef +_STDIO_H + + +73  + #_STDIO_USES_IOSTREAM + + + ) + +75  + ~ + +77 #ifde +__USE_XOPEN + + +78 #ifde +__GNUC__ + + +79 #ide +_VA_LIST_DEFINED + + +80  +_G_va_li + + tva_li +; + +81  + #_VA_LIST_DEFINED + + + ) + +84  + ~ + +89 +__BEGIN_NAMESPACE_STD + + +90 #ide +__USE_FILE_OFFSET64 + + +91  +_G_os_t + + tos_t +; + +93  +_G_os64_t + + tos_t +; + +95 +__END_NAMESPACE_STD + + +96 #ifde +__USE_LARGEFILE64 + + +97  +_G_os64_t + + tos64_t +; + +101  + #_IOFBF + 0 + + ) + +102  + #_IOLBF + 1 + + ) + +103  + #_IONBF + 2 + + ) + +107 #ide +BUFSIZ + + +108  + #BUFSIZ + +_IO_BUFSIZ + + + ) + +114 #ide +EOF + + +115  + #EOF + (-1) + + ) + +121  + #SEEK_SET + 0 + + ) + +122  + #SEEK_CUR + 1 + + ) + +123  + #SEEK_END + 2 + + ) + +126 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +128  + #P_tmpd + "/tmp" + + ) + +141  + ~ + +145  +_IO_FILE + * +d +; + +146  +_IO_FILE + * +dout +; + +147  +_IO_FILE + * +dr +; + +149  + #d + +d + + + ) + +150  + #dout + +dout + + + ) + +151  + #dr + +dr + + + ) + +153 +__BEGIN_NAMESPACE_STD + + +155  + $move + ( +__cڡ + * +__fame + +__THROW +; + +157  + $me + ( +__cڡ + * +__d +, __cڡ * +__w + +__THROW +; + +158 +__END_NAMESPACE_STD + + +160 #ifde +__USE_ATFILE + + +162  + $mt + ( +__dfd +, +__cڡ + * +__d +,  +__wfd +, + +163 +__cڡ + * +__w + +__THROW +; + +166 +__BEGIN_NAMESPACE_STD + + +171 #ide +__USE_FILE_OFFSET64 + + +172 +FILE + * + $tmpfe + ( +__wur +; + +174 #ifde +__REDIRECT + + +175 +FILE + * + `__REDIRECT + ( +tmpfe +, (), +tmpfe64 + +__wur +; + +177  + #tmpfe + +tmpfe64 + + + ) + +181 #ifde +__USE_LARGEFILE64 + + +182 +FILE + * + $tmpfe64 + ( +__wur +; + +186 * + $tmam + (* +__s + +__THROW + +__wur +; + +187 +__END_NAMESPACE_STD + + +189 #ifde +__USE_MISC + + +192 * + $tmam_r + (* +__s + +__THROW + +__wur +; + +196 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +204 * + $mam + ( +__cڡ + * +__d +, __cڡ * +__pfx +) + +205 +__THROW + +__ibu_mloc__ + +__wur +; + +209 +__BEGIN_NAMESPACE_STD + + +214  + `fo + ( +FILE + * +__am +); + +219  + `fush + ( +FILE + * +__am +); + +220 +__END_NAMESPACE_STD + + +222 #ifde +__USE_MISC + + +229  + `fush_uocked + ( +FILE + * +__am +); + +232 #ifde +__USE_GNU + + +239  + `fol + (); + +243 +__BEGIN_NAMESPACE_STD + + +244 #ide +__USE_FILE_OFFSET64 + + +249 +FILE + * + $fݒ + ( +__cڡ + * +__ri + +__fame +, + +250 +__cڡ + * +__ri + +__modes + +__wur +; + +255 +FILE + * + $eݒ + ( +__cڡ + * +__ri + +__fame +, + +256 +__cڡ + * +__ri + +__modes +, + +257 +FILE + * +__ri + +__am + +__wur +; + +259 #ifde +__REDIRECT + + +260 +FILE + * + `__REDIRECT + ( +fݒ +, ( +__cڡ + * +__ri + +__fame +, + +261 +__cڡ + * +__ri + +__modes +), +fݒ64 +) + +262 +__wur +; + +263 +FILE + * + `__REDIRECT + ( +eݒ +, ( +__cڡ + * +__ri + +__fame +, + +264 +__cڡ + * +__ri + +__modes +, + +265 +FILE + * +__ri + +__am +), +eݒ64 +) + +266 +__wur +; + +268  + #fݒ + +fݒ64 + + + ) + +269  + #eݒ + +eݒ64 + + + ) + +272 +__END_NAMESPACE_STD + + +273 #ifde +__USE_LARGEFILE64 + + +274 +FILE + * + $fݒ64 + ( +__cڡ + * +__ri + +__fame +, + +275 +__cڡ + * +__ri + +__modes + +__wur +; + +276 +FILE + * + $eݒ64 + ( +__cڡ + * +__ri + +__fame +, + +277 +__cڡ + * +__ri + +__modes +, + +278 +FILE + * +__ri + +__am + +__wur +; + +281 #ifdef +__USE_POSIX + + +283 +FILE + * + $fdݒ + ( +__fd +, +__cڡ + * +__modes + +__THROW + +__wur +; + +286 #ifdef +__USE_GNU + + +289 +FILE + * + $fݒcook + (* +__ri + +__magic_cook +, + +290 +__cڡ + * +__ri + +__modes +, + +291 +_IO_cook_io_funis_t + +__io_funcs + +__THROW + +__wur +; + +294 #ifde +__USE_XOPEN2K8 + + +296 +FILE + * + $fmemݒ + (* +__s +, +size_t + +__n +, +__cڡ + * +__modes +) + +297 +__THROW + +__wur +; + +302 +FILE + * + $ݒ_memam + (** +__buoc +, +size_t + * +__sizoc + +__THROW + +__wur +; + +306 +__BEGIN_NAMESPACE_STD + + +309  + $tbuf + ( +FILE + * +__ri + +__am +, *__ri +__buf + +__THROW +; + +313  + $tvbuf + ( +FILE + * +__ri + +__am +, *__ri +__buf +, + +314  +__modes +, +size_t + +__n + +__THROW +; + +315 +__END_NAMESPACE_STD + + +317 #ifdef +__USE_BSD + + +320  + $tbufr + ( +FILE + * +__ri + +__am +, *__ri +__buf +, + +321 +size_t + +__size + +__THROW +; + +324  + $ebuf + ( +FILE + * +__am + +__THROW +; + +328 +__BEGIN_NAMESPACE_STD + + +333  + `rtf + ( +FILE + * +__ri + +__am +, + +334 +__cڡ + * +__ri + +__fm +, ...); + +339  + `tf + ( +__cڡ + * +__ri + +__fm +, ...); + +341  + $rtf + (* +__ri + +__s +, + +342 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +348  + `vrtf + ( +FILE + * +__ri + +__s +, +__cڡ + *__ri +__fm +, + +349 +_G_va_li + +__g +); + +354  + `vtf + ( +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +); + +356  + $vrtf + (* +__ri + +__s +, +__cڡ + *__ri +__fm +, + +357 +_G_va_li + +__g + +__THROW +; + +358 +__END_NAMESPACE_STD + + +360 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +361 +__BEGIN_NAMESPACE_C99 + + +363  + $tf + (* +__ri + +__s +, +size_t + +__maxn +, + +364 +__cڡ + * +__ri + +__fm +, ...) + +365 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +367  + $vtf + (* +__ri + +__s +, +size_t + +__maxn +, + +368 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +369 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +370 +__END_NAMESPACE_C99 + + +373 #ifde +__USE_GNU + + +376  + $vartf + (** +__ri + +__r +, +__cڡ + *__ri +__f +, + +377 +_G_va_li + +__g +) + +378 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 2, 0)) +__wur +; + +379  + $__artf + (** +__ri + +__r +, + +380 +__cڡ + * +__ri + +__fmt +, ...) + +381 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 2, 3)) +__wur +; + +382  + $artf + (** +__ri + +__r +, + +383 +__cڡ + * +__ri + +__fmt +, ...) + +384 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 2, 3)) +__wur +; + +387 #ifde +__USE_XOPEN2K8 + + +394  + $vdtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, + +395 +_G_va_li + +__g +) + +396 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +397  + $dtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, ...) + +398 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +402 +__BEGIN_NAMESPACE_STD + + +407  + $fsnf + ( +FILE + * +__ri + +__am +, + +408 +__cڡ + * +__ri + +__fm +, ... +__wur +; + +413  + $snf + ( +__cڡ + * +__ri + +__fm +, ... +__wur +; + +415  + $ssnf + ( +__cڡ + * +__ri + +__s +, + +416 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +418 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +419 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +420 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +421 #ifde +__REDIRECT + + +425  + `__REDIRECT + ( +fsnf +, ( +FILE + * +__ri + +__am +, + +426 +__cڡ + * +__ri + +__fm +, ...), + +427 +__isoc99_fsnf + +__wur +; + +428  + `__REDIRECT + ( +snf +, ( +__cڡ + * +__ri + +__fm +, ...), + +429 +__isoc99_snf + +__wur +; + +430  + `__REDIRECT + ( +ssnf +, ( +__cڡ + * +__ri + +__s +, + +431 +__cڡ + * +__ri + +__fm +, ...), + +432 +__isoc99_ssnf + +__THROW +; + +434  + $__isoc99_fsnf + ( +FILE + * +__ri + +__am +, + +435 +__cڡ + * +__ri + +__fm +, ... +__wur +; + +436  + $__isoc99_snf + ( +__cڡ + * +__ri + +__fm +, ... +__wur +; + +437  + $__isoc99_ssnf + ( +__cڡ + * +__ri + +__s +, + +438 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +439  + #fsnf + +__isoc99_fsnf + + + ) + +440  + #snf + +__isoc99_snf + + + ) + +441  + #ssnf + +__isoc99_ssnf + + + ) + +445 +__END_NAMESPACE_STD + + +447 #ifdef +__USE_ISOC99 + + +448 +__BEGIN_NAMESPACE_C99 + + +453  + $vfsnf + ( +FILE + * +__ri + +__s +, +__cڡ + *__ri +__fm +, + +454 +_G_va_li + +__g +) + +455 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 2, 0)) +__wur +; + +461  + $vsnf + ( +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +462 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 1, 0)) +__wur +; + +465  + $vssnf + ( +__cڡ + * +__ri + +__s +, + +466 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +) + +467 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 2, 0))); + +469 #i! +defed + +__USE_GNU + \ + +470 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +471 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +472 #ifde +__REDIRECT + + +476  + `__REDIRECT + ( +vfsnf +, + +477 ( +FILE + * +__ri + +__s +, + +478 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +), + +479 +__isoc99_vfsnf +) + +480 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 2, 0)) +__wur +; + +481  + `__REDIRECT + ( +vsnf +, ( +__cڡ + * +__ri + +__fm +, + +482 +_G_va_li + +__g +), +__isoc99_vsnf +) + +483 + `__ibu__ + (( + $__fm__ + ( +__snf__ +, 1, 0)) +__wur +; + +484  + `__REDIRECT + ( +vssnf +, + +485 ( +__cڡ + * +__ri + +__s +, + +486 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__g +), + +487 +__isoc99_vssnf +) + +488 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__snf__ +, 2, 0))); + +490  + $__isoc99_vfsnf + ( +FILE + * +__ri + +__s +, + +491 +__cڡ + * +__ri + +__fm +, + +492 +_G_va_li + +__g + +__wur +; + +493  + $__isoc99_vsnf + ( +__cڡ + * +__ri + +__fm +, + +494 +_G_va_li + +__g + +__wur +; + +495  + $__isoc99_vssnf + ( +__cڡ + * +__ri + +__s +, + +496 +__cڡ + * +__ri + +__fm +, + +497 +_G_va_li + +__g + +__THROW +; + +498  + #vfsnf + +__isoc99_vfsnf + + + ) + +499  + #vsnf + +__isoc99_vsnf + + + ) + +500  + #vssnf + +__isoc99_vssnf + + + ) + +504 +__END_NAMESPACE_C99 + + +508 +__BEGIN_NAMESPACE_STD + + +513  + `fgc + ( +FILE + * +__am +); + +514  + `gc + ( +FILE + * +__am +); + +520  + `gch + (); + +521 +__END_NAMESPACE_STD + + +525  + #gc +( +_ + + `_IO_gc + (_) + + ) + +527 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +532  + `gc_uocked + ( +FILE + * +__am +); + +533  + `gch_uocked + (); + +536 #ifde +__USE_MISC + + +543  + `fgc_uocked + ( +FILE + * +__am +); + +547 +__BEGIN_NAMESPACE_STD + + +555  + `utc + ( +__c +, +FILE + * +__am +); + +556  + `putc + ( +__c +, +FILE + * +__am +); + +562  + `putch + ( +__c +); + +563 +__END_NAMESPACE_STD + + +567  + #putc +( +_ch +, +_ + + `_IO_putc + (_ch, _) + + ) + +569 #ifde +__USE_MISC + + +576  + `utc_uocked + ( +__c +, +FILE + * +__am +); + +579 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +584  + `putc_uocked + ( +__c +, +FILE + * +__am +); + +585  + `putch_uocked + ( +__c +); + +589 #i +defed + +__USE_SVID + || defed +__USE_MISC + \ + +590 || ( +defed + +__USE_XOPEN + && !defed +__USE_XOPEN2K +) + +592  + `gw + ( +FILE + * +__am +); + +595  + `putw + ( +__w +, +FILE + * +__am +); + +599 +__BEGIN_NAMESPACE_STD + + +604 * + $fgs + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +) + +605 +__wur +; + +612 * + $gs + (* +__s + +__wur +; + +613 +__END_NAMESPACE_STD + + +615 #ifde +__USE_GNU + + +622 * + $fgs_uocked + (* +__ri + +__s +,  +__n +, + +623 +FILE + * +__ri + +__am + +__wur +; + +627 #ifdef +__USE_XOPEN2K8 + + +638 +_IO_ssize_t + + $__gdim + (** +__ri + +__l +, + +639 +size_t + * +__ri + +__n +,  +__dim +, + +640 +FILE + * +__ri + +__am + +__wur +; + +641 +_IO_ssize_t + + $gdim + (** +__ri + +__l +, + +642 +size_t + * +__ri + +__n +,  +__dim +, + +643 +FILE + * +__ri + +__am + +__wur +; + +651 +_IO_ssize_t + + $gle + (** +__ri + +__l +, + +652 +size_t + * +__ri + +__n +, + +653 +FILE + * +__ri + +__am + +__wur +; + +657 +__BEGIN_NAMESPACE_STD + + +662  + `uts + ( +__cڡ + * +__ri + +__s +, +FILE + *__ri +__am +); + +668  + `puts + ( +__cڡ + * +__s +); + +675  + `ungc + ( +__c +, +FILE + * +__am +); + +682 +size_t + + $d + (* +__ri + +__r +, +size_t + +__size +, + +683 +size_t + +__n +, +FILE + * +__ri + +__am + +__wur +; + +688 +size_t + + `fwre + ( +__cڡ + * +__ri + +__r +, size_ +__size +, + +689 +size_t + +__n +, +FILE + * +__ri + +__s +); + +690 +__END_NAMESPACE_STD + + +692 #ifde +__USE_GNU + + +699  + `uts_uocked + ( +__cڡ + * +__ri + +__s +, + +700 +FILE + * +__ri + +__am +); + +703 #ifde +__USE_MISC + + +710 +size_t + + $d_uocked + (* +__ri + +__r +, +size_t + +__size +, + +711 +size_t + +__n +, +FILE + * +__ri + +__am + +__wur +; + +712 +size_t + + `fwre_uocked + ( +__cڡ + * +__ri + +__r +, size_ +__size +, + +713 +size_t + +__n +, +FILE + * +__ri + +__am +); + +717 +__BEGIN_NAMESPACE_STD + + +722  + `fek + ( +FILE + * +__am +,  +__off +,  +__wh +); + +727  + $l + ( +FILE + * +__am + +__wur +; + +732  + `wd + ( +FILE + * +__am +); + +733 +__END_NAMESPACE_STD + + +740 #i +defed + +__USE_LARGEFILE + || defed +__USE_XOPEN2K + + +741 #ide +__USE_FILE_OFFSET64 + + +746  + `feko + ( +FILE + * +__am +, +__off_t + +__off +,  +__wh +); + +751 +__off_t + + $lo + ( +FILE + * +__am + +__wur +; + +753 #ifde +__REDIRECT + + +754  + `__REDIRECT + ( +feko +, + +755 ( +FILE + * +__am +, +__off64_t + +__off +,  +__wh +), + +756 +feko64 +); + +757 +__off64_t + + `__REDIRECT + ( +lo +, ( +FILE + * +__am +), +lo64 +); + +759  + #feko + +feko64 + + + ) + +760  + #lo + +lo64 + + + ) + +765 +__BEGIN_NAMESPACE_STD + + +766 #ide +__USE_FILE_OFFSET64 + + +771  + `fgpos + ( +FILE + * +__ri + +__am +, +os_t + *__ri +__pos +); + +776  + `fos + ( +FILE + * +__am +, +__cڡ + +os_t + * +__pos +); + +778 #ifde +__REDIRECT + + +779  + `__REDIRECT + ( +fgpos +, ( +FILE + * +__ri + +__am +, + +780 +os_t + * +__ri + +__pos +), +fgpos64 +); + +781  + `__REDIRECT + ( +fos +, + +782 ( +FILE + * +__am +, +__cڡ + +os_t + * +__pos +), +fos64 +); + +784  + #fgpos + +fgpos64 + + + ) + +785  + #fos + +fos64 + + + ) + +788 +__END_NAMESPACE_STD + + +790 #ifde +__USE_LARGEFILE64 + + +791  + `feko64 + ( +FILE + * +__am +, +__off64_t + +__off +,  +__wh +); + +792 +__off64_t + + $lo64 + ( +FILE + * +__am + +__wur +; + +793  + `fgpos64 + ( +FILE + * +__ri + +__am +, +os64_t + *__ri +__pos +); + +794  + `fos64 + ( +FILE + * +__am +, +__cڡ + +os64_t + * +__pos +); + +797 +__BEGIN_NAMESPACE_STD + + +799  + $ + ( +FILE + * +__am + +__THROW +; + +801  + $of + ( +FILE + * +__am + +__THROW + +__wur +; + +803  + $ + ( +FILE + * +__am + +__THROW + +__wur +; + +804 +__END_NAMESPACE_STD + + +806 #ifde +__USE_MISC + + +808  + $_uocked + ( +FILE + * +__am + +__THROW +; + +809  + $of_uocked + ( +FILE + * +__am + +__THROW + +__wur +; + +810  + $_uocked + ( +FILE + * +__am + +__THROW + +__wur +; + +814 +__BEGIN_NAMESPACE_STD + + +819  + ` + ( +__cڡ + * +__s +); + +820 +__END_NAMESPACE_STD + + +826  + ~ + +829 #ifdef +__USE_POSIX + + +831  + $fo + ( +FILE + * +__am + +__THROW + +__wur +; + +834 #ifde +__USE_MISC + + +836  + $fo_uocked + ( +FILE + * +__am + +__THROW + +__wur +; + +840 #i( +defed + +__USE_POSIX2 + || defed +__USE_SVID + || defed +__USE_BSD + || \ + +841 +defed + +__USE_MISC +) + +846 +FILE + * + $pݒ + ( +__cڡ + * +__commd +, __cڡ * +__modes + +__wur +; + +852  + `po + ( +FILE + * +__am +); + +856 #ifdef +__USE_POSIX + + +858 * + $mid + (* +__s + +__THROW +; + +862 #ifde +__USE_XOPEN + + +864 * + `curid + (* +__s +); + +868 #ifdef +__USE_GNU + + +869  +oback +; + +872  + $oback_tf + ( +oback + * +__ri + +__oback +, + +873 +__cڡ + * +__ri + +__fm +, ...) + +874 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 3))); + +875  + $oback_vtf + ( +oback + * +__ri + +__oback +, + +876 +__cڡ + * +__ri + +__fm +, + +877 +_G_va_li + +__gs +) + +878 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 2, 0))); + +882 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +886  + $ockfe + ( +FILE + * +__am + +__THROW +; + +890  + $rylockfe + ( +FILE + * +__am + +__THROW + +__wur +; + +893  + $fuockfe + ( +FILE + * +__am + +__THROW +; + +896 #i +defed + +__USE_XOPEN + && !defed +__USE_XOPEN2K + && !defed +__USE_GNU + + +900  + #__ed_gt + + + ) + +901  + ~ + +906 #ifde +__USE_EXTERN_INLINES + + +907  + ~ + +909 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +910  + ~ + +912 #ifde +__LDBL_COMPAT + + +913  + ~ + +916 +__END_DECLS + + + @/usr/include/string.h + +23 #idef +_STRING_H + + +24  + #_STRING_H + 1 + + ) + +26  + ~ + +28 + g__BEGIN_DECLS + + +31  + #__ed_size_t + + + ) + +32  + #__ed_NULL + + + ) + +33  + ~ + +36 #i +defed + +__lulus + && +__GNUC_PREREQ + (4, 4) + +37  + #__CORRECT_ISO_CPP_STRING_H_PROTO + + + ) + +41 +__BEGIN_NAMESPACE_STD + + +43 * + $memy + (* +__ri + +__de +, + +44 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +45 +__THROW + + `__nnu + ((1, 2)); + +48 * + $memmove + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +) + +49 +__THROW + + `__nnu + ((1, 2)); + +50 +__END_NAMESPACE_STD + + +55 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN + + +56 * + $memcy + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +57  +__c +, +size_t + +__n +) + +58 +__THROW + + `__nnu + ((1, 2)); + +62 +__BEGIN_NAMESPACE_STD + + +64 * + $memt + (* +__s +,  +__c +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +67  + $memcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +68 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +71 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +74 * + `memchr + (* +__s +,  +__c +, +size_t + +__n +) + +75 +__THROW + + `__asm + ("memchr" +__ibu_pu__ + + `__nnu + ((1)); + +76 +__cڡ + * + `memchr + (__cڡ * +__s +,  +__c +, +size_t + +__n +) + +77 +__THROW + + `__asm + ("memchr" +__ibu_pu__ + + `__nnu + ((1)); + +79 #ifde +__OPTIMIZE__ + + +80 +__ex_ways_le + * + +81 + `memchr + (* +__s +,  +__c +, +size_t + +__n + +__THROW + + +83  + `__but_memchr + ( +__s +, +__c +, +__n +); + +86 +__ex_ways_le + +__cڡ + * + +87 + `memchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n + +__THROW + + +89  + `__but_memchr + ( +__s +, +__c +, +__n +); + +92 + } +} + +94 * + $memchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +95 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +97 +__END_NAMESPACE_STD + + +99 #ifde +__USE_GNU + + +102 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +103 "C++" * + $wmemchr + (* +__s +,  +__c +) + +104 +__THROW + + `__asm + ("wmemchr" +__ibu_pu__ + + `__nnu + ((1)); + +105 "C++" +__cڡ + * + $wmemchr + ( +__cڡ + * +__s +,  +__c +) + +106 +__THROW + + `__asm + ("wmemchr" +__ibu_pu__ + + `__nnu + ((1)); + +108 * + $wmemchr + ( +__cڡ + * +__s +,  +__c +) + +109 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +113 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +114 "C++" * + $memrchr + (* +__s +,  +__c +, +size_t + +__n +) + +115 +__THROW + + `__asm + ("memrchr" +__ibu_pu__ + + `__nnu + ((1)); + +116 "C++" +__cڡ + * + $memrchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +117 +__THROW + + `__asm + ("memrchr" +__ibu_pu__ + + `__nnu + ((1)); + +119 * + $memrchr + ( +__cڡ + * +__s +,  +__c +, +size_t + +__n +) + +120 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +125 +__BEGIN_NAMESPACE_STD + + +127 * + $ry + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +128 +__THROW + + `__nnu + ((1, 2)); + +130 * + $y + (* +__ri + +__de +, + +131 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +132 +__THROW + + `__nnu + ((1, 2)); + +135 * + $rt + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +136 +__THROW + + `__nnu + ((1, 2)); + +138 * + $t + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +139 +size_t + +__n + +__THROW + + `__nnu + ((1, 2)); + +142  + $rcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +143 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +145  + $cmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +146 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +149  + $rcl + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +150 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +152 +size_t + + $rxm + (* +__ri + +__de +, + +153 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +154 +__THROW + + `__nnu + ((2)); + +155 +__END_NAMESPACE_STD + + +157 #ifde +__USE_XOPEN2K8 + + +161  + ~ + +164  + $rcl_l + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +__lo_t + +__l +) + +165 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2, 3)); + +167 +size_t + + $rxm_l + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +, + +168 +__lo_t + +__l + +__THROW + + `__nnu + ((2, 4)); + +171 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +173 * + $rdup + ( +__cڡ + * +__s +) + +174 +__THROW + +__ibu_mloc__ + + `__nnu + ((1)); + +180 #i +defed + +__USE_XOPEN2K8 + + +181 * + $dup + ( +__cڡ + * +__rg +, +size_t + +__n +) + +182 +__THROW + +__ibu_mloc__ + + `__nnu + ((1)); + +185 #i +defed + +__USE_GNU + && defed +__GNUC__ + + +187  + #rdu +( +s +) \ + +188 ( +__exnsi__ + \ + +190 +__cڡ + * +__d + = ( +s +); \ + +191 +size_t + +__n + = + ` + ( +__d +) + 1; \ + +192 * +__w + = (* + `__but_lo + ( +__n +); \ + +193 (* + `memy + ( +__w +, +__d +, +__n +); \ + +194 + } +})) + + ) + +197  + #du +( +s +, +n +) \ + +198 ( +__exnsi__ + \ + +200 +__cڡ + * +__d + = ( +s +); \ + +201 +size_t + +__n + = + `n + ( +__d +, ( +n +)); \ + +202 * +__w + = (* + `__but_lo + ( +__n + + 1); \ + +203 +__w +[ +__n +] = '\0'; \ + +204 (* + `memy + ( +__w +, +__d +, +__n +); \ + +205 })) + + ) + +208 + g__BEGIN_NAMESPACE_STD + + +210 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +213 * +rchr + (* +__s +,  +__c +) + +214 +__THROW + +__asm + ("rchr" +__ibu_pu__ + +__nnu + ((1)); + +215 +__cڡ + * +rchr + (__cڡ * +__s +,  +__c +) + +216 +__THROW + +__asm + ("rchr" +__ibu_pu__ + +__nnu + ((1)); + +218 #ifde +__OPTIMIZE__ + + +219 +__ex_ways_le + * + +220 +rchr + (* +__s +,  +__c + + g__THROW + + +222  +__but_rchr + ( +__s +, +__c +); + +225 +__ex_ways_le + +__cڡ + * + +226 +rchr + ( +__cڡ + * +__s +,  +__c + + g__THROW + + +228  +__but_rchr + ( +__s +, +__c +); + +233 * + $rchr + ( +__cڡ + * +__s +,  +__c +) + +234 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +237 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +240 * + `chr + (* +__s +,  +__c +) + +241 +__THROW + + `__asm + ("chr" +__ibu_pu__ + + `__nnu + ((1)); + +242 +__cڡ + * + `chr + (__cڡ * +__s +,  +__c +) + +243 +__THROW + + `__asm + ("chr" +__ibu_pu__ + + `__nnu + ((1)); + +245 #ifde +__OPTIMIZE__ + + +246 +__ex_ways_le + * + +247 + `chr + (* +__s +,  +__c + +__THROW + + +249  + `__but_chr + ( +__s +, +__c +); + +252 +__ex_ways_le + +__cڡ + * + +253 + `chr + ( +__cڡ + * +__s +,  +__c + +__THROW + + +255  + `__but_chr + ( +__s +, +__c +); + +258 + } +} + +260 * + $chr + ( +__cڡ + * +__s +,  +__c +) + +261 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +263 +__END_NAMESPACE_STD + + +265 #ifde +__USE_GNU + + +268 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +269 "C++" * + $rchul + (* +__s +,  +__c +) + +270 +__THROW + + `__asm + ("rchul" +__ibu_pu__ + + `__nnu + ((1)); + +271 "C++" +__cڡ + * + $rchul + ( +__cڡ + * +__s +,  +__c +) + +272 +__THROW + + `__asm + ("rchul" +__ibu_pu__ + + `__nnu + ((1)); + +274 * + $rchul + ( +__cڡ + * +__s +,  +__c +) + +275 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +279 +__BEGIN_NAMESPACE_STD + + +282 +size_t + + $rcn + ( +__cڡ + * +__s +, __cڡ * +__je +) + +283 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +286 +size_t + + $rn + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +287 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +289 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +292 * + `brk + (* +__s +, +__cڡ + * +__ac +) + +293 +__THROW + + `__asm + ("brk" +__ibu_pu__ + + `__nnu + ((1, 2)); + +294 +__cڡ + * + `brk + (__cڡ * +__s +, __cڡ * +__ac +) + +295 +__THROW + + `__asm + ("brk" +__ibu_pu__ + + `__nnu + ((1, 2)); + +297 #ifde +__OPTIMIZE__ + + +298 +__ex_ways_le + * + +299 + `brk + (* +__s +, +__cڡ + * +__ac + +__THROW + + +301  + `__but_brk + ( +__s +, +__ac +); + +304 +__ex_ways_le + +__cڡ + * + +305 + `brk + ( +__cڡ + * +__s +, __cڡ * +__ac + +__THROW + + +307  + `__but_brk + ( +__s +, +__ac +); + +310 + } +} + +312 * + $brk + ( +__cڡ + * +__s +, __cڡ * +__ac +) + +313 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +316 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +319 * + `rr + (* +__hayack +, +__cڡ + * +__ed +) + +320 +__THROW + + `__asm + ("rr" +__ibu_pu__ + + `__nnu + ((1, 2)); + +321 +__cڡ + * + `rr + (__cڡ * +__hayack +, + +322 +__cڡ + * +__ed +) + +323 +__THROW + + `__asm + ("rr" +__ibu_pu__ + + `__nnu + ((1, 2)); + +325 #ifde +__OPTIMIZE__ + + +326 +__ex_ways_le + * + +327 + `rr + (* +__hayack +, +__cڡ + * +__ed + +__THROW + + +329  + `__but_rr + ( +__hayack +, +__ed +); + +332 +__ex_ways_le + +__cڡ + * + +333 + `rr + ( +__cڡ + * +__hayack +, __cڡ * +__ed + +__THROW + + +335  + `__but_rr + ( +__hayack +, +__ed +); + +338 + } +} + +340 * + $rr + ( +__cڡ + * +__hayack +, __cڡ * +__ed +) + +341 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +346 * + $ok + (* +__ri + +__s +, +__cڡ + *__ri +__dim +) + +347 +__THROW + + `__nnu + ((2)); + +348 +__END_NAMESPACE_STD + + +352 * + $__ok_r + (* +__ri + +__s +, + +353 +__cڡ + * +__ri + +__dim +, + +354 ** +__ri + +__ve_r +) + +355 +__THROW + + `__nnu + ((2, 3)); + +356 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +357 * + $ok_r + (* +__ri + +__s +, +__cڡ + *__ri +__dim +, + +358 ** +__ri + +__ve_r +) + +359 +__THROW + + `__nnu + ((2, 3)); + +362 #ifde +__USE_GNU + + +364 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +365 "C++" * + $rr + (* +__hayack +, +__cڡ + * +__ed +) + +366 +__THROW + + `__asm + ("rr" +__ibu_pu__ + + `__nnu + ((1, 2)); + +367 "C++" +__cڡ + * + $rr + ( +__cڡ + * +__hayack +, + +368 +__cڡ + * +__ed +) + +369 +__THROW + + `__asm + ("rr" +__ibu_pu__ + + `__nnu + ((1, 2)); + +371 * + $rr + ( +__cڡ + * +__hayack +, __cڡ * +__ed +) + +372 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +376 #ifde +__USE_GNU + + +380 * + $memmem + ( +__cڡ + * +__hayack +, +size_t + +__hayackn +, + +381 +__cڡ + * +__ed +, +size_t + +__edn +) + +382 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 3)); + +386 * + $__mempy + (* +__ri + +__de +, + +387 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +388 +__THROW + + `__nnu + ((1, 2)); + +389 * + $mempy + (* +__ri + +__de +, + +390 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +391 +__THROW + + `__nnu + ((1, 2)); + +395 +__BEGIN_NAMESPACE_STD + + +397 +size_t + + $ + ( +__cڡ + * +__s +) + +398 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +399 +__END_NAMESPACE_STD + + +401 #ifdef +__USE_XOPEN2K8 + + +404 +size_t + + $n + ( +__cڡ + * +__rg +, +size_t + +__maxn +) + +405 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +409 +__BEGIN_NAMESPACE_STD + + +411 * + $ + ( +__um + +__THROW +; + +412 +__END_NAMESPACE_STD + + +413 #i +defed + +__USE_XOPEN2K + || defed +__USE_MISC + + +421 #i +defed + +__USE_XOPEN2K + && !defed +__USE_GNU + + +424 #ifde +__REDIRECT_NTH + + +425  + `__REDIRECT_NTH + ( +_r +, + +426 ( +__um +, * +__buf +, +size_t + +__bu +), + +427 +__xpg__r + + `__nnu + ((2)); + +429  + $__xpg__r + ( +__um +, * +__buf +, +size_t + +__bu +) + +430 +__THROW + + `__nnu + ((2)); + +431  + #_r + +__xpg__r + + + ) + +436 * + $_r + ( +__um +, * +__buf +, +size_t + +__bu +) + +437 +__THROW + + `__nnu + ((2)); + +441 #ifde +__USE_XOPEN2K8 + + +443 * + $_l + ( +__um +, +__lo_t + +__l + +__THROW +; + +449  + $__bzo + (* +__s +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +451 #ifde +__USE_BSD + + +453  + $bcy + ( +__cڡ + * +__c +, * +__de +, +size_t + +__n +) + +454 +__THROW + + `__nnu + ((1, 2)); + +457  + $bzo + (* +__s +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +460  + $bcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +461 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +464 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +467 * + `dex + (* +__s +,  +__c +) + +468 +__THROW + + `__asm + ("dex" +__ibu_pu__ + + `__nnu + ((1)); + +469 +__cڡ + * + `dex + (__cڡ * +__s +,  +__c +) + +470 +__THROW + + `__asm + ("dex" +__ibu_pu__ + + `__nnu + ((1)); + +472 #i +defed + +__OPTIMIZE__ + && !defed +__CORRECT_ISO_CPP_STRINGS_H_PROTO + + +473 +__ex_ways_le + * + +474 + `dex + (* +__s +,  +__c + +__THROW + + +476  + `__but_dex + ( +__s +, +__c +); + +479 +__ex_ways_le + +__cڡ + * + +480 + `dex + ( +__cڡ + * +__s +,  +__c + +__THROW + + +482  + `__but_dex + ( +__s +, +__c +); + +485 + } +} + +487 * + $dex + ( +__cڡ + * +__s +,  +__c +) + +488 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +492 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +495 * + `rdex + (* +__s +,  +__c +) + +496 +__THROW + + `__asm + ("rdex" +__ibu_pu__ + + `__nnu + ((1)); + +497 +__cڡ + * + `rdex + (__cڡ * +__s +,  +__c +) + +498 +__THROW + + `__asm + ("rdex" +__ibu_pu__ + + `__nnu + ((1)); + +500 #i +defed + +__OPTIMIZE__ + && !defed +__CORRECT_ISO_CPP_STRINGS_H_PROTO + + +501 +__ex_ways_le + * + +502 + `rdex + (* +__s +,  +__c + +__THROW + + +504  + `__but_rdex + ( +__s +, +__c +); + +507 +__ex_ways_le + +__cڡ + * + +508 + `rdex + ( +__cڡ + * +__s +,  +__c + +__THROW + + +510  + `__but_rdex + ( +__s +, +__c +); + +513 + } +} + +515 * + $rdex + ( +__cڡ + * +__s +,  +__c +) + +516 +__THROW + +__ibu_pu__ + + `__nnu + ((1)); + +521  + $ffs + ( +__i + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +525 #ifdef +__USE_GNU + + +526  + $ff + ( +__l + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +527 #ifde +__GNUC__ + + +528 +__exnsi__ +  + $ffl + ( +__ +) + +529 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +534  + $rcmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +535 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +538  + $cmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, +size_t + +__n +) + +539 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +542 #ifdef +__USE_GNU + + +545  + $rcmp_l + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, + +546 +__lo_t + +__loc +) + +547 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2, 3)); + +549  + $cmp_l + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +, + +550 +size_t + +__n +, +__lo_t + +__loc +) + +551 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2, 4)); + +554 #ifdef +__USE_BSD + + +557 * + $rp + (** +__ri + +__rgp +, + +558 +__cڡ + * +__ri + +__dim +) + +559 +__THROW + + `__nnu + ((1, 2)); + +562 #ifdef +__USE_XOPEN2K8 + + +564 * + $rsigl + ( +__sig + +__THROW +; + +567 * + $__py + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +568 +__THROW + + `__nnu + ((1, 2)); + +569 * + $py + (* +__ri + +__de +, +__cڡ + *__ri +__c +) + +570 +__THROW + + `__nnu + ((1, 2)); + +574 * + $__y + (* +__ri + +__de +, + +575 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +576 +__THROW + + `__nnu + ((1, 2)); + +577 * + $y + (* +__ri + +__de +, + +578 +__cڡ + * +__ri + +__c +, +size_t + +__n +) + +579 +__THROW + + `__nnu + ((1, 2)); + +582 #ifdef +__USE_GNU + + +584  + $rvscmp + ( +__cڡ + * +__s1 +, __cڡ * +__s2 +) + +585 +__THROW + +__ibu_pu__ + + `__nnu + ((1, 2)); + +588 * + $ry + (* +__rg + +__THROW + + `__nnu + ((1)); + +591 * + $memob + (* +__s +, +size_t + +__n + +__THROW + + `__nnu + ((1)); + +593 #ide +bame + + +598 #ifde +__CORRECT_ISO_CPP_STRING_H_PROTO + + +599 "C++" * + $bame + (* +__fame +) + +600 +__THROW + + `__asm + ("bame" + `__nnu + ((1)); + +601 "C++" +__cڡ + * + $bame + ( +__cڡ + * +__fame +) + +602 +__THROW + + `__asm + ("bame" + `__nnu + ((1)); + +604 * + $bame + ( +__cڡ + * +__fame + +__THROW + + `__nnu + ((1)); + +610 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +611 #i +defed + +__OPTIMIZE__ + && !defed +__OPTIMIZE_SIZE__ + \ + +612 && ! +defed + +__NO_INLINE__ + && !defed +__lulus + + +632  + ~ + +635  + ~ + +638 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +640  + ~ + +644 +__END_DECLS + + + @/usr/include/bits/huge_val.h + +22 #ide +_MATH_H + + +28 #i +__GNUC_PREREQ +(3,3) + +29  + #HUGE_VAL + ( + `__but_huge_v +()) + + ) + +30 #i +__GNUC_PREREQ +(2,96) + +31  + #HUGE_VAL + ( +__exnsi__ + 0x1.0 +p2047 +) + + ) + +32 #i +defed + +__GNUC__ + + +34  + #HUGE_VAL + \ + +35 ( +__exnsi__ + \ + +36 ((uni {  +__l + + `__ibu__ +(( + `__mode__ +( +__DI__ +)));  +__d +; }) \ + +37 { +__l +: 0x7ff0000000000000ULL }). +__d +) + + ) + +41  + ~ + +43 uni {  + m__c +[8];  + m__d +; } + t__huge_v_t +; + +45 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +46  + #__HUGE_VAL_bys + { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } + + ) + +48 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +49  + #__HUGE_VAL_bys + { 0, 0, 0, 0, 0, 0, 0xf0, 0x7} + + ) + +52  +__huge_v_t + + g__huge_v + = { +__HUGE_VAL_bys + }; + +53  + #HUGE_VAL + ( +__huge_v +. +__d +) + + ) + + @/usr/include/bits/huge_valf.h + +22 #ide +_MATH_H + + +28 #i +__GNUC_PREREQ +(3,3) + +29  + #HUGE_VALF + ( + `__but_huge_vf +()) + + ) + +30 #i +__GNUC_PREREQ +(2,96) + +31  + #HUGE_VALF + ( +__exnsi__ + 0x1.0 +p255f +) + + ) + +32 #i +defed + +__GNUC__ + + +34  + #HUGE_VALF + \ + +35 ( +__exnsi__ + \ + +36 ((uni {  +__l + + `__ibu__ +(( + `__mode__ +( +__SI__ +)));  +__d +; }) \ + +37 { +__l +: 0x7f800000UL }). +__d +) + + ) + +41 uni {  + m__c +[4];  + m__f +; } + t__huge_vf_t +; + +43 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +44  + #__HUGE_VALF_bys + { 0x7f, 0x80, 0, 0 } + + ) + +46 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +47  + #__HUGE_VALF_bys + { 0, 0, 0x80, 0x7} + + ) + +50  +__huge_vf_t + + g__huge_vf + = { +__HUGE_VALF_bys + }; + +51  + #HUGE_VALF + ( +__huge_vf +. +__f +) + + ) + + @/usr/include/bits/huge_vall.h + +21 #ide +_MATH_H + + +25 #i +__GNUC_PREREQ +(3,3) + +26  + #HUGE_VALL + ( + `__but_huge_vl +()) + + ) + +28  + #HUGE_VALL + (( +HUGE_VAL +) + + ) + + @/usr/include/bits/inf.h + +20 #ide +_MATH_H + + +26 #i +__GNUC_PREREQ +(3,3) + +27  + #INFINITY + ( + `__but_ff +()) + + ) + +29  + #INFINITY + +HUGE_VALF + + + ) + + @/usr/include/bits/mathcalls.h + +46 #ide +_MATH_H + + +53 +_Mdoub_BEGIN_NAMESPACE + + +55 +__MATHCALL + ( +acos +,, ( +_Mdoub_ + +__x +)); + +57 +__MATHCALL + ( +as +,, ( +_Mdoub_ + +__x +)); + +59 +__MATHCALL + ( + +,, ( +_Mdoub_ + +__x +)); + +61 +__MATHCALL + ( +2 +,, ( +_Mdoub_ + +__y +, _Mdoub_ +__x +)); + +64 +__MATHCALL + ( +cos +,, ( +_Mdoub_ + +__x +)); + +66 +__MATHCALL + ( +s +,, ( +_Mdoub_ + +__x +)); + +68 +__MATHCALL + ( +n +,, ( +_Mdoub_ + +__x +)); + +73 +__MATHCALL + ( +cosh +,, ( +_Mdoub_ + +__x +)); + +75 +__MATHCALL + ( +sh +,, ( +_Mdoub_ + +__x +)); + +77 +__MATHCALL + ( +nh +,, ( +_Mdoub_ + +__x +)); + +78 + g_Mdoub_END_NAMESPACE + + +80 #ifde +__USE_GNU + + +82 +__MATHDECL + (, +scos +,, + +83 ( +_Mdoub_ + +__x +, _Mdoub_ * +__sx +, _Mdoub_ * +__cosx +)); + +86 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_ISOC99 + + +87 +__BEGIN_NAMESPACE_C99 + + +89 +__MATHCALL + ( +acosh +,, ( +_Mdoub_ + +__x +)); + +91 +__MATHCALL + ( +ash +,, ( +_Mdoub_ + +__x +)); + +93 +__MATHCALL + ( +h +,, ( +_Mdoub_ + +__x +)); + +94 + g__END_NAMESPACE_C99 + + +99 +_Mdoub_BEGIN_NAMESPACE + + +101 +__MATHCALL + ( +exp +,, ( +_Mdoub_ + +__x +)); + +104 +__MATHCALL + ( +exp +,, ( +_Mdoub_ + +__x +, * +__expڒt +)); + +107 +__MATHCALL + ( +ldexp +,, ( +_Mdoub_ + +__x +,  +__expڒt +)); + +110 +__MATHCALL + ( +log +,, ( +_Mdoub_ + +__x +)); + +113 +__MATHCALL + ( +log10 +,, ( +_Mdoub_ + +__x +)); + +116 +__MATHCALL + ( +modf +,, ( +_Mdoub_ + +__x +, _Mdoub_ * +__ +)); + +117 + g_Mdoub_END_NAMESPACE + + +119 #ifde +__USE_GNU + + +121 +__MATHCALL + ( +exp10 +,, ( +_Mdoub_ + +__x +)); + +123 +__MATHCALL + ( +pow10 +,, ( +_Mdoub_ + +__x +)); + +126 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_ISOC99 + + +127 +__BEGIN_NAMESPACE_C99 + + +129 +__MATHCALL + ( +expm1 +,, ( +_Mdoub_ + +__x +)); + +132 +__MATHCALL + ( +log1p +,, ( +_Mdoub_ + +__x +)); + +135 +__MATHCALL + ( +logb +,, ( +_Mdoub_ + +__x +)); + +136 + g__END_NAMESPACE_C99 + + +139 #ifde +__USE_ISOC99 + + +140 +__BEGIN_NAMESPACE_C99 + + +142 +__MATHCALL + ( +exp2 +,, ( +_Mdoub_ + +__x +)); + +145 +__MATHCALL + ( +log2 +,, ( +_Mdoub_ + +__x +)); + +146 + g__END_NAMESPACE_C99 + + +152 +_Mdoub_BEGIN_NAMESPACE + + +154 +__MATHCALL + ( +pow +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +157 +__MATHCALL + ( +sq +,, ( +_Mdoub_ + +__x +)); + +158 + g_Mdoub_END_NAMESPACE + + +160 #i +defed + +__USE_MISC + || defed +__USE_XOPEN + || defed +__USE_ISOC99 + + +161 +__BEGIN_NAMESPACE_C99 + + +163 +__MATHCALL + ( +hyp +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +164 + g__END_NAMESPACE_C99 + + +167 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_ISOC99 + + +168 +__BEGIN_NAMESPACE_C99 + + +170 +__MATHCALL + ( +cb +,, ( +_Mdoub_ + +__x +)); + +171 + g__END_NAMESPACE_C99 + + +177 +_Mdoub_BEGIN_NAMESPACE + + +179 +__MATHCALLX + ( + +,, ( +_Mdoub_ + +__x +), ( +__cڡ__ +)); + +182 +__MATHCALLX + ( +bs +,, ( +_Mdoub_ + +__x +), ( +__cڡ__ +)); + +185 +__MATHCALLX + ( +o +,, ( +_Mdoub_ + +__x +), ( +__cڡ__ +)); + +188 +__MATHCALL + ( +fmod +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +193 +__MATHDECL_1 + (, +__isf +,, ( +_Mdoub_ + +__vue +) +__ibu__ + (( +__cڡ__ +)); + +196 +__MATHDECL_1 + (, +__fe +,, ( +_Mdoub_ + +__vue +) +__ibu__ + (( +__cڡ__ +)); + +197 + g_Mdoub_END_NAMESPACE + + +199 #ifde +__USE_MISC + + +202 +__MATHDECL_1 + (, +isf +,, ( +_Mdoub_ + +__vue +) +__ibu__ + (( +__cڡ__ +)); + +205 +__MATHDECL_1 + (, +fe +,, ( +_Mdoub_ + +__vue +) +__ibu__ + (( +__cڡ__ +)); + +208 +__MATHCALL + ( +dm +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +212 +__MATHCALL + ( +signifind +,, ( +_Mdoub_ + +__x +)); + +215 #i +defed + +__USE_MISC + || defed +__USE_ISOC99 + + +216 +__BEGIN_NAMESPACE_C99 + + +218 +__MATHCALLX + ( +cysign +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +), ( +__cڡ__ +)); + +219 + g__END_NAMESPACE_C99 + + +222 #ifde +__USE_ISOC99 + + +223 +__BEGIN_NAMESPACE_C99 + + +225 +__MATHCALLX + ( +n +,, ( +__cڡ + * +__gb +), ( +__cڡ__ +)); + +226 + g__END_NAMESPACE_C99 + + +231 +__MATHDECL_1 + (, +__i +,, ( +_Mdoub_ + +__vue +) +__ibu__ + (( +__cڡ__ +)); + +233 #i +defed + +__USE_MISC + || defed +__USE_XOPEN + + +235 +__MATHDECL_1 + (, +i +,, ( +_Mdoub_ + +__vue +) +__ibu__ + (( +__cڡ__ +)); + +238 +__MATHCALL + ( +j0 +,, ( +_Mdoub_ +)); + +239 +__MATHCALL + ( +j1 +,, ( +_Mdoub_ +)); + +240 +__MATHCALL + ( +jn +,, (, +_Mdoub_ +)); + +241 +__MATHCALL + ( +y0 +,, ( +_Mdoub_ +)); + +242 +__MATHCALL + ( +y1 +,, ( +_Mdoub_ +)); + +243 +__MATHCALL + ( +yn +,, (, +_Mdoub_ +)); + +247 #i +defed + +__USE_MISC + || defed +__USE_XOPEN + || defed +__USE_ISOC99 + + +248 +__BEGIN_NAMESPACE_C99 + + +250 +__MATHCALL + ( +f +,, ( +_Mdoub_ +)); + +251 +__MATHCALL + ( +fc +,, ( +_Mdoub_ +)); + +252 +__MATHCALL + ( +lgamma +,, ( +_Mdoub_ +)); + +253 + g__END_NAMESPACE_C99 + + +256 #ifde +__USE_ISOC99 + + +257 +__BEGIN_NAMESPACE_C99 + + +259 +__MATHCALL + ( +tgamma +,, ( +_Mdoub_ +)); + +260 + g__END_NAMESPACE_C99 + + +263 #i +defed + +__USE_MISC + || defed +__USE_XOPEN + + +265 +__MATHCALL + ( +gamma +,, ( +_Mdoub_ +)); + +268 #ifde +__USE_MISC + + +272 +__MATHCALL + ( +lgamma +, +_r +, ( +_Mdoub_ +, * +__signgamp +)); + +276 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_ISOC99 + + +277 +__BEGIN_NAMESPACE_C99 + + +280 +__MATHCALL + ( +rt +,, ( +_Mdoub_ + +__x +)); + +283 +__MATHCALLX + ( +x +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +), ( +__cڡ__ +)); + +284 #i +defed + +__USE_ISOC99 + && !defed +__LDBL_COMPAT + + +285 +__MATHCALLX + ( +xowd +,, ( +_Mdoub_ + +__x +,  +__y +), ( +__cڡ__ +)); + +289 +__MATHCALL + ( +mad +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +291 #i +defed + +__USE_MISC + || defed +__USE_ISOC99 + + +293 +__MATHCALL + ( +slbn +,, ( +_Mdoub_ + +__x +,  +__n +)); + +297 +__MATHDECL + (, +ogb +,, ( +_Mdoub_ + +__x +)); + +300 #ifde +__USE_ISOC99 + + +302 +__MATHCALL + ( +slb +,, ( +_Mdoub_ + +__x +,  +__n +)); + +306 +__MATHCALL + ( +ìbyt +,, ( +_Mdoub_ + +__x +)); + +310 +__MATHCALLX + ( +round +,, ( +_Mdoub_ + +__x +), ( +__cڡ__ +)); + +314 +__MATHCALLX + ( +unc +,, ( +_Mdoub_ + +__x +), ( +__cڡ__ +)); + +319 +__MATHCALL + ( +mquo +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +, * +__quo +)); + +326 +__MATHDECL + (, +̚t +,, ( +_Mdoub_ + +__x +)); + +327 +__MATHDECL + (, +rt +,, ( +_Mdoub_ + +__x +)); + +331 +__MATHDECL + (, +ound +,, ( +_Mdoub_ + +__x +)); + +332 +__MATHDECL + (, +round +,, ( +_Mdoub_ + +__x +)); + +336 +__MATHCALL + ( +fdim +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +339 +__MATHCALL + ( +fmax +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +342 +__MATHCALL + ( +fm +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +)); + +346 +__MATHDECL_1 + (, +__assify +,, ( +_Mdoub_ + +__vue +)) + +347 +__ibu__ + (( +__cڡ__ +)); + +350 +__MATHDECL_1 + (, +__signb +,, ( +_Mdoub_ + +__vue +)) + +351 +__ibu__ + (( +__cڡ__ +)); + +355 +__MATHCALL + ( +fma +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__y +, _Mdoub_ +__z +)); + +358 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_ISOC99 + + +359 + g__END_NAMESPACE_C99 + + +362 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + + +364 +__MATHCALL + ( +slb +,, ( +_Mdoub_ + +__x +, _Mdoub_ +__n +)); + + @/usr/include/bits/mathdef.h + +19 #i! +defed + +_MATH_H + && !defed +_COMPLEX_H + + +23 #i +defed + +__USE_ISOC99 + && defed +_MATH_H + && !defed +_MATH_H_MATHDEF + + +24  + #_MATH_H_MATHDEF + 1 + + ) + +26  + ~ + +28 #i +__WORDSIZE + =64 || ( +defed + +__FLT_EVAL_METHOD__ + && __FLT_EVAL_METHOD__ == 0) + +31  + tt_t +; + +32  + tdoub_t +; + +38  + tt_t +; + +40  + tdoub_t +; + +45  + #FP_ILOGB0 + (-2147483647 - 1) + + ) + +46  + #FP_ILOGBNAN + (-2147483647 - 1) + + ) + + @/usr/include/bits/mathinline.h + +21 #ide +_MATH_H + + +25  + ~ + +27 #ide +__ex_le + + +28  + #__MATH_INLINE + +__le + + + ) + +30  + #__MATH_INLINE + +__ex_le + + + ) + +34 #i +defed + +__USE_ISOC99 + && defed +__GNUC__ + && __GNUC__ >= 2 + +37 +__MATH_INLINE +  + +38 +__NTH + ( + $__signbf + ( +__x +)) + +40 #i +__WORDSIZE + == 32 + +41 +__exnsi__ + uni {  +__f +;  +__i +; } +__u + = { __f: +__x + }; + +42  +__u +. +__i + < 0; + +44  +__m +; + +45 + `__asm + ("pmovmskb %1, %0" : "" ( +__m +: "x" ( +__x +)); + +46  +__m + & 0x8; + +48 + } +} + +49 +__MATH_INLINE +  + +50 +__NTH + ( + $__signb + ( +__x +)) + +52 #i +__WORDSIZE + == 32 + +53 +__exnsi__ + uni {  +__d +;  +__i +[2]; } +__u + = { __d: +__x + }; + +54  +__u +. +__i +[1] < 0; + +56  +__m +; + +57 + `__asm + ("pmovmskb %1, %0" : "" ( +__m +: "x" ( +__x +)); + +58  +__m + & 0x80; + +60 + } +} + +61 +__MATH_INLINE +  + +62 +__NTH + ( + $__signbl + ( +__x +)) + +64 +__exnsi__ + uni {  +__l +;  +__i +[3]; } +__u + = { __l: +__x + }; + +65  ( +__u +. +__i +[2] & 0x8000) != 0; + +66 + } +} + + @/usr/include/bits/nan.h + +20 #ide +_MATH_H + + +27 #i +__GNUC_PREREQ +(3,3) + +29  + #NAN + ( + `__but_nf + ("")) + + ) + +31 #i +defed + +__GNUC__ + + +33  + #NAN + \ + +34 ( +__exnsi__ + \ + +35 ((uni {  +__l + + `__ibu__ + (( + `__mode__ + ( +__SI__ +)));  +__d +; }) \ + +36 { +__l +: 0x7fc00000UL }). +__d +) + + ) + +40  + ~ + +42 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +43  + #__n_bys + { 0x7f, 0xc0, 0, 0 } + + ) + +45 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +46  + #__n_bys + { 0, 0, 0xc0, 0x7} + + ) + +49 uni {  + m__c +[4];  + m__d +; } +__n_uni + + +50 + g__ibu_ud__ + = { +__n_bys + }; + +51  + #NAN + ( +__n_uni +. +__d +) + + ) + + @/usr/include/bits/stdio-ldbl.h + +20 #ide +_STDIO_H + + +24 +__BEGIN_NAMESPACE_STD + + +25 + $__LDBL_REDIR_DECL + ( +rtf +) + +26 + $__LDBL_REDIR_DECL + ( +tf +) + +27 + $__LDBL_REDIR_DECL + ( +rtf +) + +28 + $__LDBL_REDIR_DECL + ( +vrtf +) + +29 + $__LDBL_REDIR_DECL + ( +vtf +) + +30 + $__LDBL_REDIR_DECL + ( +vrtf +) + +31 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +32 && ! +defed + +__REDIRECT + \ + +33 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +34 + $__LDBL_REDIR1_DECL + ( +fsnf +, +__dbl___isoc99_fsnf +) + +35 + $__LDBL_REDIR1_DECL + ( +snf +, +__dbl___isoc99_snf +) + +36 + $__LDBL_REDIR1_DECL + ( +ssnf +, +__dbl___isoc99_ssnf +) + +38 + $__LDBL_REDIR_DECL + ( +fsnf +) + +39 + $__LDBL_REDIR_DECL + ( +snf +) + +40 + $__LDBL_REDIR_DECL + ( +ssnf +) + +42 +__END_NAMESPACE_STD + + +44 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +45 +__BEGIN_NAMESPACE_C99 + + +46 + $__LDBL_REDIR_DECL + ( +tf +) + +47 + $__LDBL_REDIR_DECL + ( +vtf +) + +48 +__END_NAMESPACE_C99 + + +51 #ifdef +__USE_ISOC99 + + +52 +__BEGIN_NAMESPACE_C99 + + +53 #i! +defed + +__USE_GNU + && !defed +__REDIRECT + \ + +54 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +55 + $__LDBL_REDIR1_DECL + ( +vfsnf +, +__dbl___isoc99_vfsnf +) + +56 + $__LDBL_REDIR1_DECL + ( +vsnf +, +__dbl___isoc99_vsnf +) + +57 + $__LDBL_REDIR1_DECL + ( +vssnf +, +__dbl___isoc99_vssnf +) + +59 + $__LDBL_REDIR_DECL + ( +vfsnf +) + +60 + $__LDBL_REDIR_DECL + ( +vssnf +) + +61 + $__LDBL_REDIR_DECL + ( +vsnf +) + +63 +__END_NAMESPACE_C99 + + +66 #ifde +__USE_GNU + + +67 + $__LDBL_REDIR_DECL + ( +vdtf +) + +68 + $__LDBL_REDIR_DECL + ( +dtf +) + +69 + $__LDBL_REDIR_DECL + ( +vartf +) + +70 + $__LDBL_REDIR_DECL + ( +__artf +) + +71 + $__LDBL_REDIR_DECL + ( +artf +) + +72 + $__LDBL_REDIR_DECL + ( +oback_tf +) + +73 + $__LDBL_REDIR_DECL + ( +oback_vtf +) + +76 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +77 + $__LDBL_REDIR_DECL + ( +__rtf_chk +) + +78 + $__LDBL_REDIR_DECL + ( +__vrtf_chk +) + +79 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +80 + $__LDBL_REDIR_DECL + ( +__tf_chk +) + +81 + $__LDBL_REDIR_DECL + ( +__vtf_chk +) + +83 #i +__USE_FORTIFY_LEVEL + > 1 + +84 + $__LDBL_REDIR_DECL + ( +__rtf_chk +) + +85 + $__LDBL_REDIR_DECL + ( +__tf_chk +) + +86 + $__LDBL_REDIR_DECL + ( +__vrtf_chk +) + +87 + $__LDBL_REDIR_DECL + ( +__vtf_chk +) + +88 #ifde +__USE_GNU + + +89 + $__LDBL_REDIR_DECL + ( +__artf_chk +) + +90 + $__LDBL_REDIR_DECL + ( +__vartf_chk +) + +91 + $__LDBL_REDIR_DECL + ( +__dtf_chk +) + +92 + $__LDBL_REDIR_DECL + ( +__vdtf_chk +) + +93 + $__LDBL_REDIR_DECL + ( +__oback_tf_chk +) + +94 + $__LDBL_REDIR_DECL + ( +__oback_vtf_chk +) + + @/usr/include/bits/stdio.h + +20 #ide +_STDIO_H + + +24 #ide +__ex_le + + +25  + #__STDIO_INLINE + +le + + + ) + +27  + #__STDIO_INLINE + +__ex_le + + + ) + +31 #ifde +__USE_EXTERN_INLINES + + +34 #i!( +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le +) + +36 +__STDIO_INLINE +  + +37 + $vtf + ( +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +39  + `vrtf + ( +dout +, +__fmt +, +__g +); + +40 + } +} + +44 +__STDIO_INLINE +  + +45 + $gch + () + +47  + `_IO_gc + ( +d +); + +48 + } +} + +51 #ifde +__USE_MISC + + +53 +__STDIO_INLINE +  + +54 + $fgc_uocked + ( +FILE + * +__ +) + +56  + `_IO_gc_uocked + ( +__ +); + +57 + } +} + +61 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +63 +__STDIO_INLINE +  + +64 + $gc_uocked + ( +FILE + * +__ +) + +66  + `_IO_gc_uocked + ( +__ +); + +67 + } +} + +70 +__STDIO_INLINE +  + +71 + $gch_uocked + () + +73  + `_IO_gc_uocked + ( +d +); + +74 + } +} + +79 +__STDIO_INLINE +  + +80 + $putch + ( +__c +) + +82  + `_IO_putc + ( +__c +, +dout +); + +83 + } +} + +86 #ifde +__USE_MISC + + +88 +__STDIO_INLINE +  + +89 + $utc_uocked + ( +__c +, +FILE + * +__am +) + +91  + `_IO_putc_uocked + ( +__c +, +__am +); + +92 + } +} + +96 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +98 +__STDIO_INLINE +  + +99 + $putc_uocked + ( +__c +, +FILE + * +__am +) + +101  + `_IO_putc_uocked + ( +__c +, +__am +); + +102 + } +} + +105 +__STDIO_INLINE +  + +106 + $putch_uocked + ( +__c +) + +108  + `_IO_putc_uocked + ( +__c +, +dout +); + +109 + } +} + +113 #ifdef +__USE_GNU + + +115 +__STDIO_INLINE + +_IO_ssize_t + + +116 + $gle + (** +__l +, +size_t + * +__n +, +FILE + * +__am +) + +118  + `__gdim + ( +__l +, +__n +, '\n', +__am +); + +119 + } +} + +123 #ifde +__USE_MISC + + +125 +__STDIO_INLINE +  + +126 +__NTH + ( + $of_uocked + ( +FILE + * +__am +)) + +128  + `_IO_of_uocked + ( +__am +); + +129 + } +} + +132 +__STDIO_INLINE +  + +133 +__NTH + ( + $_uocked + ( +FILE + * +__am +)) + +135  + `_IO__uocked + ( +__am +); + +136 + } +} + +142 #i +defed + +__USE_MISC + && defed +__GNUC__ + && defed +__OPTIMIZE__ + \ + +143 && ! +defed + + g__lulus + + +145  + #d_uocked +( +r +, +size +, +n +, +am +) \ + +146 ( + `__exnsi__ + (( + `__but_cڡt_p + ( +size +&& __but_cڡt_( +n +) \ + +147 && ( +size_t +( +size +* (size_t( +n +) <= 8 \ + +148 && ( +size_t +( +size +) != 0) \ + +149 ? ({ * +__r + = (*( +r +); \ + +150 +FILE + * +__am + = ( +am +); \ + +151 +size_t + +__t +; \ + +152  +__t + = ( +size_t +( +size +* (size_t( +n +); \ + +153 +__t + > 0; --__cnt) \ + +155  +__c + = + `_IO_gc_uocked + ( +__am +); \ + +156 i( +__c + = +EOF +) \ + +158 * +__r +++ = +__c +; \ + +160 (( +size_t +( +size +* (size_t( +n +- +__t +) \ + +161 / ( +size_t +( +size +); }) \ + +162 : ((( + `__but_cڡt_p + ( +size +&& ( +size_t +) (size) == 0) \ + +163 || ( + `__but_cڡt_p + ( +n +&& ( +size_t +) (n) == 0)) \ + +165 ? ((( +r +), (( +am +), (( +size +), \ + +166 (( +n +), ( +size_t +) 0) \ + +167 : + `d_uocked + ( +r +, +size +, +n +, +am +)))) + + ) + +169  + #fwre_uocked +( +r +, +size +, +n +, +am +) \ + +170 ( + `__exnsi__ + (( + `__but_cڡt_p + ( +size +&& __but_cڡt_( +n +) \ + +171 && ( +size_t +( +size +* (size_t( +n +) <= 8 \ + +172 && ( +size_t +( +size +) != 0) \ + +173 ? ({ cڡ * +__r + = (cڡ *( +r +); \ + +174 +FILE + * +__am + = ( +am +); \ + +175 +size_t + +__t +; \ + +176  +__t + = ( +size_t +( +size +* (size_t( +n +); \ + +177 +__t + > 0; --__cnt) \ + +178 i( + `_IO_putc_uocked + (* +__r +++, +__am += +EOF +) \ + +180 (( +size_t +( +size +* (size_t( +n +- +__t +) \ + +181 / ( +size_t +( +size +); }) \ + +182 : ((( + `__but_cڡt_p + ( +size +&& ( +size_t +) (size) == 0) \ + +183 || ( + `__but_cڡt_p + ( +n +&& ( +size_t +) (n) == 0)) \ + +185 ? ((( +r +), (( +am +), (( +size +), \ + +186 (( +n +), ( +size_t +) 0) \ + +187 : + `fwre_uocked + ( +r +, +size +, +n +, +am +)))) + + ) + +191 #unde +__STDIO_INLINE + + + @/usr/include/bits/stdio2.h + +20 #ide +_STDIO_H + + +24  + $__rtf_chk + (* +__ri + +__s +,  +__ag +, +size_t + +__ +, + +25 +__cڡ + * +__ri + +__fm +, ... +__THROW +; + +26  + $__vrtf_chk + (* +__ri + +__s +,  +__ag +, +size_t + +__ +, + +27 +__cڡ + * +__ri + +__fm +, + +28 +_G_va_li + +__ + +__THROW +; + +30 #ifde +__va_g_ck + + +31 +__ex_ways_le +  + +32 + `__NTH + ( + $rtf + (* +__ri + +__s +, +__cڡ + *__ri +__fmt +, ...)) + +34  + `__but___rtf_chk + ( +__s +, +__USE_FORTIFY_LEVEL + - 1, + +35 + `__bos + ( +__s +), +__fmt +, + `__va_g_ck + ()); + +36 + } +} + +37 #i! +defed + +__lulus + + +38  + #rtf +( +r +, ...) \ + +39 + `__but___rtf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +40 +__VA_ARGS__ +) + + ) + +43 +__ex_ways_le +  + +44 +__NTH + ( + $vrtf + (* +__ri + +__s +, +__cڡ + *__ri +__fmt +, + +45 +_G_va_li + +__ +)) + +47  + `__but___vrtf_chk + ( +__s +, +__USE_FORTIFY_LEVEL + - 1, + +48 + `__bos + ( +__s +), +__fmt +, +__ +); + +49 + } +} + +51 #i +defed + +__USE_BSD + || defed +__USE_ISOC99 + || defed +__USE_UNIX98 + + +53  + $__tf_chk + (* +__ri + +__s +, +size_t + +__n +,  +__ag +, + +54 +size_t + +__ +, +__cڡ + * +__ri + +__fm +, + +55 ... +__THROW +; + +56  + $__vtf_chk + (* +__ri + +__s +, +size_t + +__n +,  +__ag +, + +57 +size_t + +__ +, +__cڡ + * +__ri + +__fm +, + +58 +_G_va_li + +__ + +__THROW +; + +60 #ifde +__va_g_ck + + +61 +__ex_ways_le +  + +62 + `__NTH + ( + $tf + (* +__ri + +__s +, +size_t + +__n +, + +63 +__cڡ + * +__ri + +__fmt +, ...)) + +65  + `__but___tf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +66 + `__bos + ( +__s +), +__fmt +, + `__va_g_ck + ()); + +67 + } +} + +68 #i! +defed + +__lulus + + +69  + #tf +( +r +, +n +, ...) \ + +70 + `__but___tf_chk + ( +r +, +n +, +__USE_FORTIFY_LEVEL + - 1, + `__bos + (str), \ + +71 +__VA_ARGS__ +) + + ) + +74 +__ex_ways_le +  + +75 +__NTH + ( + $vtf + (* +__ri + +__s +, +size_t + +__n +, + +76 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +)) + +78  + `__but___vtf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +79 + `__bos + ( +__s +), +__fmt +, +__ +); + +80 + } +} + +84 #i +__USE_FORTIFY_LEVEL + > 1 + +86  +__rtf_chk + ( +FILE + * +__ri + +__am +,  +__ag +, + +87 +__cڡ + * +__ri + +__fm +, ...); + +88  +__tf_chk + ( +__ag +, +__cڡ + * +__ri + +__fm +, ...); + +89  +__vrtf_chk + ( +FILE + * +__ri + +__am +,  +__ag +, + +90 +__cڡ + * +__ri + +__fm +, +_G_va_li + +__ +); + +91  +__vtf_chk + ( +__ag +, +__cڡ + * +__ri + +__fm +, + +92 +_G_va_li + +__ +); + +94 #ifde +__va_g_ck + + +95 +__ex_ways_le +  + +96 + $rtf + ( +FILE + * +__ri + +__am +, +__cڡ + *__ri +__fmt +, ...) + +98  + `__rtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +99 + `__va_g_ck + ()); + +100 + } +} + +102 +__ex_ways_le +  + +103 + $tf + ( +__cڡ + * +__ri + +__fmt +, ...) + +105  + `__tf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + `__va_g_ck + ()); + +106 + } +} + +107 #i! +defed + +__lulus + + +108  + #tf +(...) \ + +109 + `__tf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +110  + #rtf +( +am +, ...) \ + +111 + `__rtf_chk + ( +am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +114 +__ex_ways_le +  + +115 + $vtf + ( +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +) + +117 #ifde +__USE_EXTERN_INLINES + + +118  + `__vrtf_chk + ( +dout +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +120  + `__vtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +122 + } +} + +124 +__ex_ways_le +  + +125 + $vrtf + ( +FILE + * +__ri + +__am +, + +126 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +) + +128  + `__vrtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +129 + } +} + +131 #ifde +__USE_GNU + + +133  + $__artf_chk + (** +__ri + +__r +,  +__ag +, + +134 +__cڡ + * +__ri + +__fmt +, ...) + +135 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 3, 4)) +__wur +; + +136  + $__vartf_chk + (** +__ri + +__r +,  +__ag +, + +137 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +138 +__THROW + + `__ibu__ + (( + $__fm__ + ( +__tf__ +, 3, 0)) +__wur +; + +139  + $__dtf_chk + ( +__fd +,  +__ag +, +__cڡ + * +__ri + +__fmt +, + +140 ... + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +141  + $__vdtf_chk + ( +__fd +,  +__ag +, + +142 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__g +) + +143 + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +144  + $__oback_tf_chk + ( +oback + * +__ri + +__oback +, + +145  +__ag +, +__cڡ + * +__ri + +__fm +, + +147 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 4))); + +148  + $__oback_vtf_chk + ( +oback + * +__ri + +__oback +, + +149  +__ag +, + +150 +__cڡ + * +__ri + +__fm +, + +151 +_G_va_li + +__gs +) + +152 +__THROW + + `__ibu__ + (( + `__fm__ + ( +__tf__ +, 3, 0))); + +154 #ifde +__va_g_ck + + +155 +__ex_ways_le +  + +156 + `__NTH + ( + $artf + (** +__ri + +__r +, +__cڡ + *__ri +__fmt +, ...)) + +158  + `__artf_chk + ( +__r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +159 + `__va_g_ck + ()); + +160 + } +} + +162 +__ex_ways_le +  + +163 +__NTH + ( + $__artf + (** +__ri + +__r +, +__cڡ + *__ri +__fmt +, + +166  + `__artf_chk + ( +__r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +167 + `__va_g_ck + ()); + +168 + } +} + +170 +__ex_ways_le +  + +171 + $dtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, ...) + +173  + `__dtf_chk + ( +__fd +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +174 + `__va_g_ck + ()); + +175 + } +} + +177 +__ex_ways_le +  + +178 +__NTH + ( + $oback_tf + ( +oback + * +__ri + +__oback +, + +179 +__cڡ + * +__ri + +__fmt +, ...)) + +181  + `__oback_tf_chk + ( +__oback +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +182 + `__va_g_ck + ()); + +183 + } +} + +184 #i! +defed + +__lulus + + +185  + #artf +( +r +, ...) \ + +186 + `__artf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +187  + #__artf +( +r +, ...) \ + +188 + `__artf_chk + ( +r +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +189  + #dtf +( +fd +, ...) \ + +190 + `__dtf_chk + ( +fd +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +191  + #oback_tf +( +oback +, ...) \ + +192 + `__oback_tf_chk + ( +oback +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +195 +__ex_ways_le +  + +196 +__NTH + ( + $vartf + (** +__ri + +__r +, +__cڡ + *__ri +__fmt +, + +197 +_G_va_li + +__ +)) + +199  + `__vartf_chk + ( +__r +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +200 + } +} + +202 +__ex_ways_le +  + +203 + $vdtf + ( +__fd +, +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +) + +205  + `__vdtf_chk + ( +__fd +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +206 + } +} + +208 +__ex_ways_le +  + +209 +__NTH + ( + $oback_vtf + ( +oback + * +__ri + +__oback +, + +210 +__cڡ + * +__ri + +__fmt +, +_G_va_li + +__ +)) + +212  + `__oback_vtf_chk + ( +__oback +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +213 +__ +); + +214 + } +} + +220 * + $__gs_chk + (* +__r +, +size_t + +__wur +; + +221 * + `__REDIRECT + ( +__gs_wn +, (* +__r +), +gs +) + +222 +__wur + + `__wljr + ("please use fgets or getline instead, gets can't " + +225 +__ex_ways_le + +__wur + * + +226 + $gs + (* +__r +) + +228 i( + `__bos + ( +__r +!( +size_t +) -1) + +229  + `__gs_chk + ( +__r +, + `__bos + (__str)); + +230  + `__gs_wn + ( +__r +); + +231 + } +} + +233 * + $__fgs_chk + (* +__ri + +__s +, +size_t + +__size +,  +__n +, + +234 +FILE + * +__ri + +__am + +__wur +; + +235 * + `__REDIRECT + ( +__fgs_s +, + +236 (* +__ri + +__s +,  +__n +, + +237 +FILE + * +__ri + +__am +), +fgs + +__wur +; + +238 * + `__REDIRECT + ( +__fgs_chk_wn +, + +239 (* +__ri + +__s +, +size_t + +__size +,  +__n +, + +240 +FILE + * +__ri + +__am +), +__fgs_chk +) + +241 +__wur + + `__wljr + ("fgets called with bigger sizehanength " + +244 +__ex_ways_le + +__wur + * + +245 + $fgs + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +) + +247 i( + `__bos + ( +__s +!( +size_t +) -1) + +249 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +250  + `__fgs_chk + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +252 i(( +size_t + +__n + > + `__bos + ( +__s +)) + +253  + `__fgs_chk_wn + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +255  + `__fgs_s + ( +__s +, +__n +, +__am +); + +256 + } +} + +258 +size_t + + $__d_chk + (* +__ri + +__r +, +size_t + +__ +, + +259 +size_t + +__size +, size_ +__n +, + +260 +FILE + * +__ri + +__am + +__wur +; + +261 +size_t + + `__REDIRECT + ( +__d_s +, + +262 (* +__ri + +__r +, +size_t + +__size +, + +263 +size_t + +__n +, +FILE + * +__ri + +__am +), + +264 +d + +__wur +; + +265 +size_t + + `__REDIRECT + ( +__d_chk_wn +, + +266 (* +__ri + +__r +, +size_t + +__ +, + +267 +size_t + +__size +, size_ +__n +, + +268 +FILE + * +__ri + +__am +), + +269 +__d_chk +) + +270 +__wur + + `__wljr + ("fread called with bigger size *membhanength " + +273 +__ex_ways_le + +__wur + +size_t + + +274 + $d + (* +__ri + +__r +, +size_t + +__size +, size_ +__n +, + +275 +FILE + * +__ri + +__am +) + +277 i( + `__bos0 + ( +__r +!( +size_t +) -1) + +279 i(! + `__but_cڡt_p + ( +__size +) + +280 || ! + `__but_cڡt_p + ( +__n +) + +281 || ( +__size + | +__n +>((( +size_t +) 1) << (8 *  (size_t) / 2))) + +282  + `__d_chk + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, +__am +); + +284 i( +__size + * +__n + > + `__bos0 + ( +__r +)) + +285  + `__d_chk_wn + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, +__am +); + +287  + `__d_s + ( +__r +, +__size +, +__n +, +__am +); + +288 + } +} + +290 #ifde +__USE_GNU + + +291 * + $__fgs_uocked_chk + (* +__ri + +__s +, +size_t + +__size +, + +292  +__n +, +FILE + * +__ri + +__am + +__wur +; + +293 * + `__REDIRECT + ( +__fgs_uocked_s +, + +294 (* +__ri + +__s +,  +__n +, + +295 +FILE + * +__ri + +__am +), +fgs_uocked + +__wur +; + +296 * + `__REDIRECT + ( +__fgs_uocked_chk_wn +, + +297 (* +__ri + +__s +, +size_t + +__size +,  +__n +, + +298 +FILE + * +__ri + +__am +), +__fgs_uocked_chk +) + +299 +__wur + + `__wljr + ("fgets_unlocked called with bigger sizehanength " + +302 +__ex_ways_le + +__wur + * + +303 + $fgs_uocked + (* +__ri + +__s +,  +__n +, +FILE + *__ri +__am +) + +305 i( + `__bos + ( +__s +!( +size_t +) -1) + +307 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +308  + `__fgs_uocked_chk + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +310 i(( +size_t + +__n + > + `__bos + ( +__s +)) + +311  + `__fgs_uocked_chk_wn + ( +__s +, + `__bos + (__s), +__n +, +__am +); + +313  + `__fgs_uocked_s + ( +__s +, +__n +, +__am +); + +314 + } +} + +317 #ifde +__USE_MISC + + +318 #unde +d_uocked + + +319 +size_t + + $__d_uocked_chk + (* +__ri + +__r +, +size_t + +__ +, + +320 +size_t + +__size +, size_ +__n +, + +321 +FILE + * +__ri + +__am + +__wur +; + +322 +size_t + + `__REDIRECT + ( +__d_uocked_s +, + +323 (* +__ri + +__r +, +size_t + +__size +, + +324 +size_t + +__n +, +FILE + * +__ri + +__am +), + +325 +d_uocked + +__wur +; + +326 +size_t + + `__REDIRECT + ( +__d_uocked_chk_wn +, + +327 (* +__ri + +__r +, +size_t + +__ +, + +328 +size_t + +__size +, size_ +__n +, + +329 +FILE + * +__ri + +__am +), + +330 +__d_uocked_chk +) + +331 +__wur + + `__wljr + ("fread_unlocked called with bigger size *membhan " + +334 +__ex_ways_le + +__wur + +size_t + + +335 + $d_uocked + (* +__ri + +__r +, +size_t + +__size +, size_ +__n +, + +336 +FILE + * +__ri + +__am +) + +338 i( + `__bos0 + ( +__r +!( +size_t +) -1) + +340 i(! + `__but_cڡt_p + ( +__size +) + +341 || ! + `__but_cڡt_p + ( +__n +) + +342 || ( +__size + | +__n +>((( +size_t +) 1) << (8 *  (size_t) / 2))) + +343  + `__d_uocked_chk + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, + +344 +__am +); + +346 i( +__size + * +__n + > + `__bos0 + ( +__r +)) + +347  + `__d_uocked_chk_wn + ( +__r +, + `__bos0 + (__r), +__size +, +__n +, + +348 +__am +); + +351 #ifde +__USE_EXTERN_INLINES + + +352 i( + `__but_cڡt_p + ( +__size +) + +353 && + `__but_cڡt_p + ( +__n +) + +354 && ( +__size + | +__n +< ((( +size_t +) 1) << (8 *  (size_t) / 2)) + +355 && +__size + * +__n + <= 8) + +357 +size_t + +__t + = +__size + * +__n +; + +358 * +__ + = (* +__r +; + +359 i( +__t + == 0) + +362 ; +__t + > 0; --__cnt) + +364  +__c + = + `_IO_gc_uocked + ( +__am +); + +365 i( +__c + = +EOF +) + +367 * +__ +++ = +__c +; + +369  ( +__ + - (* +__r +/ +__size +; + +372  + `__d_uocked_s + ( +__r +, +__size +, +__n +, +__am +); + +373 + } +} + + @/usr/include/bits/stdio_lim.h + +19 #i! +defed + +_STDIO_H + && !defed +__ed_FOPEN_MAX + && !defed +__ed_IOV_MAX + + +23 #ifde +_STDIO_H + + +24  + #L_tmam + 20 + + ) + +25  + #TMP_MAX + 238328 + + ) + +26  + #FILENAME_MAX + 4096 + + ) + +28 #ifde +__USE_POSIX + + +29  + #L_mid + 9 + + ) + +30 #i! +defed + +__USE_XOPEN2K + || defed +__USE_GNU + + +31  + #L_curid + 9 + + ) + +36 #i +defed + +__ed_FOPEN_MAX + || defed +_STDIO_H + + +37 #unde +FOPEN_MAX + + +38  + #FOPEN_MAX + 16 + + ) + +41 #i +defed + +__ed_IOV_MAX + && !defed +IOV_MAX + + +42  + #IOV_MAX + 1024 + + ) + + @/usr/include/bits/string.h + +20 #ide +_STRING_H + + +26  + #_STRING_ARCH_uligd + 1 + + ) + + @/usr/include/bits/string2.h + +21 #ide +_STRING_H + + +25 #i! +defed + +__NO_STRING_INLINES + && !defed +__BOUNDED_POINTERS__ + + +42 #ide +__STRING_INLINE + + +43 #ifde +__lulus + + +44  + #__STRING_INLINE + +le + + + ) + +46  + #__STRING_INLINE + +__ex_le + + + ) + +50 #i +_STRING_ARCH_uligd + + +52  + ~ + +53  + ~ + +55 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +56  + #__STRING2_SMALL_GET16 +( +c +, +idx +) \ + +57 ((( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1] << 8 \ + +58 | (( +__cڡ + *(__cڡ *( +c +))[ +idx +]) + + ) + +59  + #__STRING2_SMALL_GET32 +( +c +, +idx +) \ + +60 ((((( +__cڡ + *(__cڡ *( +c +))[ +idx + + 3] << 8 \ + +61 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 2]) << 8 \ + +62 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1]) << 8 \ + +63 | (( +__cڡ + *(__cڡ *( +c +))[ +idx +]) + + ) + +65  + #__STRING2_SMALL_GET16 +( +c +, +idx +) \ + +66 ((( +__cڡ + *(__cڡ *( +c +))[ +idx +] << 8 \ + +67 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1]) + + ) + +68  + #__STRING2_SMALL_GET32 +( +c +, +idx +) \ + +69 ((((( +__cڡ + *(__cڡ *( +c +))[ +idx +] << 8 \ + +70 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 1]) << 8 \ + +71 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 2]) << 8 \ + +72 | (( +__cڡ + *(__cڡ *( +c +))[ +idx + + 3]) + + ) + +77  + #__STRING2_COPY_TYPE +( +N +) \ + +78 ru {  +__r +[ +N +]; } \ + +79 + t__ibu__ + (( + t__cked__ +) + t__STRING2_COPY_ARR +## + tN + + + ) + +80 + t__STRING2_COPY_TYPE + (2); + +81 +__STRING2_COPY_TYPE + (3); + +82 +__STRING2_COPY_TYPE + (4); + +83 +__STRING2_COPY_TYPE + (5); + +84 +__STRING2_COPY_TYPE + (6); + +85 +__STRING2_COPY_TYPE + (7); + +86 +__STRING2_COPY_TYPE + (8); + +87 #unde +__STRING2_COPY_TYPE + + +93  + #__rg2_1br_p +( +__x +) \ + +94 (( +size_t +)(cڡ *)(( +__x ++ 1- (size_t)(cڡ *)(__x=1) + + ) + +97 #i! +defed + +_HAVE_STRING_ARCH_memt + + +98 #i! +__GNUC_PREREQ + (3, 0) + +99 #i +_STRING_ARCH_uligd + + +100  + #memt +( +s +, +c +, +n +) \ + +101 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +n +) && (n) <= 16 \ + +102 ? (( +n +) == 1 \ + +103 ? + `__memt_1 + ( +s +, +c +) \ + +104 : + `__memt_gc + ( +s +, +c +, +n +)) \ + +105 : ( + `__but_cڡt_p + ( +c +) && (c) == '\0' \ + +106 ? ({ * +__s + = ( +s +); + `__bzo + (__s, +n +); __s; }) \ + +107 : + `memt + ( +s +, +c +, +n +)))) + + ) + +109  + #__memt_1 +( +s +, +c +({ * +__s + = (s); \ + +110 *(( +__ut8_t + * +__s +(__ut8_t +c +; __s; }) + + ) + +112  + #__memt_gc +( +s +, +c +, +n +) \ + +113 ({ * +__s + = ( +s +); \ + +115  +__ui +; \ + +116  +__usi +; \ + +117  +__uc +; \ + +118 } * +__u + = +__s +; \ + +119 +__ut8_t + +__c + = (__ut8_t( +c +); \ + +122 (( +n +)) \ + +125 +__u +-> +__ui + = +__c + * 0x01010101; \ + +126 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +128 +__u +-> +__ui + = +__c + * 0x01010101; \ + +129 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +131 +__u +-> +__ui + = +__c + * 0x01010101; \ + +132 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +134 +__u +-> +__usi + = ( +__c + * 0x0101; \ + +135 +__u + = + `__exnsi__ + ((*) __u + 2); \ + +136 +__u +-> +__uc + = ( +__c +; \ + +140 +__u +-> +__ui + = +__c + * 0x01010101; \ + +141 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +143 +__u +-> +__ui + = +__c + * 0x01010101; \ + +144 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +146 +__u +-> +__ui + = +__c + * 0x01010101; \ + +147 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +149 +__u +-> +__usi + = ( +__c + * 0x0101; \ + +153 +__u +-> +__ui + = +__c + * 0x01010101; \ + +154 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +156 +__u +-> +__ui + = +__c + * 0x01010101; \ + +157 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +159 +__u +-> +__ui + = +__c + * 0x01010101; \ + +160 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +162 +__u +-> +__uc + = ( +__c +; \ + +166 +__u +-> +__ui + = +__c + * 0x01010101; \ + +167 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +169 +__u +-> +__ui + = +__c + * 0x01010101; \ + +170 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +172 +__u +-> +__ui + = +__c + * 0x01010101; \ + +173 +__u + = + `__exnsi__ + ((*) __u + 4); \ + +175 +__u +-> +__ui + = +__c + * 0x01010101; \ + +180 +__s +; }) + + ) + +182  + #memt +( +s +, +c +, +n +) \ + +183 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) && (c) == '\0' \ + +184 ? ({ * +__s + = ( +s +); + `__bzo + (__s, +n +); __s; }) \ + +185 : + `memt + ( +s +, +c +, +n +))) + + ) + +194 #i +__GNUC_PREREQ + (2, 91) + +195  + #__bzo +( +s +, +n + + `__but_memt + (s, '\0',) + + ) + +203 #ifde +__USE_GNU + + +204 #i! +defed + +_HAVE_STRING_ARCH_mempy + || defed +_FORCE_INLINES + + +205 #ide +_HAVE_STRING_ARCH_mempy + + +206 #i +__GNUC_PREREQ + (3, 4) + +207  + #__mempy +( +de +, +c +, +n + + `__but_mempy + (de, src,) + + ) + +208 #i +__GNUC_PREREQ + (3, 0) + +209  + #__mempy +( +de +, +c +, +n +) \ + +210 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +211 && + `__rg2_1br_p + ( +c +&& +n + <= 8 \ + +212 ? + `__but_memy + ( +de +, +c +, +n +) + (n) \ + +213 : + `__mempy + ( +de +, +c +, +n +))) + + ) + +215  + #__mempy +( +de +, +c +, +n +) \ + +216 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +217 && + `__rg2_1br_p + ( +c +&& +n + <= 8 \ + +218 ? + `__mempy_sml + ( +de +, + `__mempy_gs + ( +c +), +n +) \ + +219 : + `__mempy + ( +de +, +c +, +n +))) + + ) + +223  + #mempy +( +de +, +c +, +n + + `__mempy + (de, src,) + + ) + +226 #i! +__GNUC_PREREQ + (3, 0|| +defed + +_FORCE_INLINES + + +227 #i +_STRING_ARCH_uligd + + +228 #ide +_FORCE_INLINES + + +229  + #__mempy_gs +( +c +) \ + +230 (( +__cڡ + *( +c +))[0], ((__const *) (src))[2], \ + +231 (( +__cڡ + *( +c +))[4], ((__const *) (src))[6], \ + +232 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 0), \ + +233 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 4), \ + +234 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 0), \ + +235 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 4) + + ) + +237 +__STRING_INLINE + * +__mempy_sml + (*, , , , , + +238 +__ut16_t +, __ut16_t, +__ut32_t +, + +239 +__ut32_t +, +size_t +); + +240 +__STRING_INLINE + * + +241 + $__mempy_sml + (* +__de1 +, + +242  +__c0_1 +,  +__c2_1 +,  +__c4_1 +,  +__c6_1 +, + +243 +__ut16_t + +__c0_2 +, __ut16_ +__c4_2 +, + +244 +__ut32_t + +__c0_4 +, __ut32_ +__c4_4 +, + +245 +size_t + +__ +) + +248 +__ut32_t + +__ui +; + +249 +__ut16_t + +__usi +; + +250  +__uc +; + +251  +__c +; + +252 } * +__u + = +__de1 +; + +253 ( +__ +) + +256 +__u +-> +__c + = +__c0_1 +; + +257 +__u + = + `__exnsi__ + ((*) __u + 1); + +260 +__u +-> +__usi + = +__c0_2 +; + +261 +__u + = + `__exnsi__ + ((*) __u + 2); + +264 +__u +-> +__usi + = +__c0_2 +; + +265 +__u + = + `__exnsi__ + ((*) __u + 2); + +266 +__u +-> +__c + = +__c2_1 +; + +267 +__u + = + `__exnsi__ + ((*) __u + 1); + +270 +__u +-> +__ui + = +__c0_4 +; + +271 +__u + = + `__exnsi__ + ((*) __u + 4); + +274 +__u +-> +__ui + = +__c0_4 +; + +275 +__u + = + `__exnsi__ + ((*) __u + 4); + +276 +__u +-> +__c + = +__c4_1 +; + +277 +__u + = + `__exnsi__ + ((*) __u + 1); + +280 +__u +-> +__ui + = +__c0_4 +; + +281 +__u + = + `__exnsi__ + ((*) __u + 4); + +282 +__u +-> +__usi + = +__c4_2 +; + +283 +__u + = + `__exnsi__ + ((*) __u + 2); + +286 +__u +-> +__ui + = +__c0_4 +; + +287 +__u + = + `__exnsi__ + ((*) __u + 4); + +288 +__u +-> +__usi + = +__c4_2 +; + +289 +__u + = + `__exnsi__ + ((*) __u + 2); + +290 +__u +-> +__c + = +__c6_1 +; + +291 +__u + = + `__exnsi__ + ((*) __u + 1); + +294 +__u +-> +__ui + = +__c0_4 +; + +295 +__u + = + `__exnsi__ + ((*) __u + 4); + +296 +__u +-> +__ui + = +__c4_4 +; + +297 +__u + = + `__exnsi__ + ((*) __u + 4); + +300  (* +__u +; + +301 + } +} + +303 #ide +_FORCE_INLINES + + +304  + #__mempy_gs +( +c +) \ + +305 (( +__cڡ + *( +c +))[0], \ + +306 + `__exnsi__ + (( +__STRING2_COPY_ARR2 +) \ + +307 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1] } }), \ + +308 + `__exnsi__ + (( +__STRING2_COPY_ARR3 +) \ + +309 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +310 (( +__cڡ + *( +c +))[2] } }), \ + +311 + `__exnsi__ + (( +__STRING2_COPY_ARR4 +) \ + +312 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +313 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3] } }), \ + +314 + `__exnsi__ + (( +__STRING2_COPY_ARR5 +) \ + +315 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +316 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +317 (( +__cڡ + *( +c +))[4] } }), \ + +318 + `__exnsi__ + (( +__STRING2_COPY_ARR6 +) \ + +319 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +320 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +321 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5] } }), \ + +322 + `__exnsi__ + (( +__STRING2_COPY_ARR7 +) \ + +323 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +324 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +325 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +326 (( +__cڡ + *( +c +))[6] } }), \ + +327 + `__exnsi__ + (( +__STRING2_COPY_ARR8 +) \ + +328 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +329 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +330 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +331 (( +__cڡ + *( +c +))[6], ((__cڡ *(c))[7] } }) + + ) + +333 +__STRING_INLINE + * +__mempy_sml + (*, , +__STRING2_COPY_ARR2 +, + +334 +__STRING2_COPY_ARR3 +, + +335 +__STRING2_COPY_ARR4 +, + +336 +__STRING2_COPY_ARR5 +, + +337 +__STRING2_COPY_ARR6 +, + +338 +__STRING2_COPY_ARR7 +, + +339 +__STRING2_COPY_ARR8 +, +size_t +); + +340 +__STRING_INLINE + * + +341 + $__mempy_sml + (* +__de +,  +__c1 +, + +342 +__STRING2_COPY_ARR2 + +__c2 +, +__STRING2_COPY_ARR3 + +__c3 +, + +343 +__STRING2_COPY_ARR4 + +__c4 +, +__STRING2_COPY_ARR5 + +__c5 +, + +344 +__STRING2_COPY_ARR6 + +__c6 +, +__STRING2_COPY_ARR7 + +__c7 +, + +345 +__STRING2_COPY_ARR8 + +__c8 +, +size_t + +__ +) + +348  +__c +; + +349 +__STRING2_COPY_ARR2 + +__s2 +; + +350 +__STRING2_COPY_ARR3 + +__s3 +; + +351 +__STRING2_COPY_ARR4 + +__s4 +; + +352 +__STRING2_COPY_ARR5 + +__s5 +; + +353 +__STRING2_COPY_ARR6 + +__s6 +; + +354 +__STRING2_COPY_ARR7 + +__s7 +; + +355 +__STRING2_COPY_ARR8 + +__s8 +; + +356 } * +__u + = +__de +; + +357 ( +__ +) + +360 +__u +-> +__c + = +__c1 +; + +363 +__exnsi__ + +__u +-> +__s2 + = +__c2 +; + +366 +__exnsi__ + +__u +-> +__s3 + = +__c3 +; + +369 +__exnsi__ + +__u +-> +__s4 + = +__c4 +; + +372 +__exnsi__ + +__u +-> +__s5 + = +__c5 +; + +375 +__exnsi__ + +__u +-> +__s6 + = +__c6 +; + +378 +__exnsi__ + +__u +-> +__s7 + = +__c7 +; + +381 +__exnsi__ + +__u +-> +__s8 + = +__c8 +; + +384  + `__exnsi__ + ((* +__u + + +__ +); + +385 + } +} + +393 #ide +_HAVE_STRING_ARCH_rchr + + +394 * +__wmemchr + (cڡ * +__s +,  +__c +); + +395 #i +__GNUC_PREREQ + (3, 2) + +396  + #rchr +( +s +, +c +) \ + +397 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& !__but_cڡt_( +s +) \ + +398 && ( +c +) == '\0' \ + +399 ? (* + `__wmemchr + ( +s +, +c +) \ + +400 : + `__but_rchr + ( +s +, +c +))) + + ) + +402  + #rchr +( +s +, +c +) \ + +403 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) && (c) == '\0' \ + +404 ? (* + `__wmemchr + ( +s +, +c +) \ + +405 : + `rchr + ( +s +, +c +))) + + ) + +411 #i(! +defed + +_HAVE_STRING_ARCH_ry + && ! +__GNUC_PREREQ + (3, 0)) \ + +412 || +defed + + g_FORCE_INLINES + + +413 #i! +defed + +_HAVE_STRING_ARCH_ry + && ! +__GNUC_PREREQ + (3, 0) + +414  + #ry +( +de +, +c +) \ + +415 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +416 ? ( + `__rg2_1br_p + ( +c +&& + ` + (src) + 1 <= 8 \ + +417 ? + `__ry_sml + ( +de +, + `__ry_gs + ( +c +), \ + +418 + ` + ( +c +) + 1) \ + +419 : (* + `memy + ( +de +, +c +, + ` + (src) + 1)) \ + +420 : + `ry + ( +de +, +c +))) + + ) + +423 #i +_STRING_ARCH_uligd + + +424 #ide +_FORCE_INLINES + + +425  + #__ry_gs +( +c +) \ + +426 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 0), \ + +427 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 4), \ + +428 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 0), \ + +429 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 4) + + ) + +431 +__STRING_INLINE + * +__ry_sml + (*, +__ut16_t +, __uint16_t, + +432 +__ut32_t +, __ut32_t, +size_t +); + +433 +__STRING_INLINE + * + +434 + $__ry_sml + (* +__de +, + +435 +__ut16_t + +__c0_2 +, __ut16_ +__c4_2 +, + +436 +__ut32_t + +__c0_4 +, __ut32_ +__c4_4 +, + +437 +size_t + +__ +) + +440 +__ut32_t + +__ui +; + +441 +__ut16_t + +__usi +; + +442  +__uc +; + +443 } * +__u + = (* +__de +; + +444 ( +__ +) + +447 +__u +-> +__uc + = '\0'; + +450 +__u +-> +__usi + = +__c0_2 +; + +453 +__u +-> +__usi + = +__c0_2 +; + +454 +__u + = + `__exnsi__ + ((*) __u + 2); + +455 +__u +-> +__uc + = '\0'; + +458 +__u +-> +__ui + = +__c0_4 +; + +461 +__u +-> +__ui + = +__c0_4 +; + +462 +__u + = + `__exnsi__ + ((*) __u + 4); + +463 +__u +-> +__uc + = '\0'; + +466 +__u +-> +__ui + = +__c0_4 +; + +467 +__u + = + `__exnsi__ + ((*) __u + 4); + +468 +__u +-> +__usi + = +__c4_2 +; + +471 +__u +-> +__ui + = +__c0_4 +; + +472 +__u + = + `__exnsi__ + ((*) __u + 4); + +473 +__u +-> +__usi + = +__c4_2 +; + +474 +__u + = + `__exnsi__ + ((*) __u + 2); + +475 +__u +-> +__uc + = '\0'; + +478 +__u +-> +__ui + = +__c0_4 +; + +479 +__u + = + `__exnsi__ + ((*) __u + 4); + +480 +__u +-> +__ui + = +__c4_4 +; + +483  +__de +; + +484 + } +} + +486 #ide +_FORCE_INLINES + + +487  + #__ry_gs +( +c +) \ + +488 + `__exnsi__ + (( +__STRING2_COPY_ARR2 +) \ + +489 { { (( +__cڡ + *( +c +))[0], '\0' } }), \ + +490 + `__exnsi__ + (( +__STRING2_COPY_ARR3 +) \ + +491 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +493 + `__exnsi__ + (( +__STRING2_COPY_ARR4 +) \ + +494 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +495 (( +__cڡ + *( +c +))[2], '\0' } }), \ + +496 + `__exnsi__ + (( +__STRING2_COPY_ARR5 +) \ + +497 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +498 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +500 + `__exnsi__ + (( +__STRING2_COPY_ARR6 +) \ + +501 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +502 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +503 (( +__cڡ + *( +c +))[4], '\0' } }), \ + +504 + `__exnsi__ + (( +__STRING2_COPY_ARR7 +) \ + +505 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +506 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +507 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +509 + `__exnsi__ + (( +__STRING2_COPY_ARR8 +) \ + +510 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +511 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +512 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +513 (( +__cڡ + *( +c +))[6], '\0' } }) + + ) + +515 +__STRING_INLINE + * +__ry_sml + (*, +__STRING2_COPY_ARR2 +, + +516 +__STRING2_COPY_ARR3 +, + +517 +__STRING2_COPY_ARR4 +, + +518 +__STRING2_COPY_ARR5 +, + +519 +__STRING2_COPY_ARR6 +, + +520 +__STRING2_COPY_ARR7 +, + +521 +__STRING2_COPY_ARR8 +, +size_t +); + +522 +__STRING_INLINE + * + +523 + $__ry_sml + (* +__de +, + +524 +__STRING2_COPY_ARR2 + +__c2 +, +__STRING2_COPY_ARR3 + +__c3 +, + +525 +__STRING2_COPY_ARR4 + +__c4 +, +__STRING2_COPY_ARR5 + +__c5 +, + +526 +__STRING2_COPY_ARR6 + +__c6 +, +__STRING2_COPY_ARR7 + +__c7 +, + +527 +__STRING2_COPY_ARR8 + +__c8 +, +size_t + +__ +) + +530  +__c +; + +531 +__STRING2_COPY_ARR2 + +__s2 +; + +532 +__STRING2_COPY_ARR3 + +__s3 +; + +533 +__STRING2_COPY_ARR4 + +__s4 +; + +534 +__STRING2_COPY_ARR5 + +__s5 +; + +535 +__STRING2_COPY_ARR6 + +__s6 +; + +536 +__STRING2_COPY_ARR7 + +__s7 +; + +537 +__STRING2_COPY_ARR8 + +__s8 +; + +538 } * +__u + = (* +__de +; + +539 ( +__ +) + +542 +__u +-> +__c + = '\0'; + +545 +__exnsi__ + +__u +-> +__s2 + = +__c2 +; + +548 +__exnsi__ + +__u +-> +__s3 + = +__c3 +; + +551 +__exnsi__ + +__u +-> +__s4 + = +__c4 +; + +554 +__exnsi__ + +__u +-> +__s5 + = +__c5 +; + +557 +__exnsi__ + +__u +-> +__s6 + = +__c6 +; + +560 +__exnsi__ + +__u +-> +__s7 + = +__c7 +; + +563 +__exnsi__ + +__u +-> +__s8 + = +__c8 +; + +566  +__de +; + +567 + } +} + +573 #ifde +__USE_GNU + + +574 #i! +defed + +_HAVE_STRING_ARCH_py + || defed +_FORCE_INLINES + + +575 #ide +_HAVE_STRING_ARCH_py + + +576 #i +__GNUC_PREREQ + (3, 4) + +577  + #__py +( +de +, +c + + `__but_py + (de, src) + + ) + +578 #i +__GNUC_PREREQ + (3, 0) + +579  + #__py +( +de +, +c +) \ + +580 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +581 ? ( + `__rg2_1br_p + ( +c +&& + ` + (src) + 1 <= 8 \ + +582 ? + `__but_ry + ( +de +, +c ++ + ` + (src) \ + +583 : ((*( +__mempy +( +de +, +c +, + ` + (src) + 1) \ + +585 : + `__py + ( +de +, +c +))) + + ) + +587  + #__py +( +de +, +c +) \ + +588 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +) \ + +589 ? ( + `__rg2_1br_p + ( +c +&& + ` + (src) + 1 <= 8 \ + +590 ? + `__py_sml + ( +de +, + `__py_gs + ( +c +), \ + +591 + ` + ( +c +) + 1) \ + +592 : ((*( +__mempy +( +de +, +c +, + ` + (src) + 1) \ + +594 : + `__py + ( +de +, +c +))) + + ) + +598  + #py +( +de +, +c + + `__py + (de, src) + + ) + +601 #i! +__GNUC_PREREQ + (3, 0|| +defed + +_FORCE_INLINES + + +602 #i +_STRING_ARCH_uligd + + +603 #ide +_FORCE_INLINES + + +604  + #__py_gs +( +c +) \ + +605 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 0), \ + +606 +__exnsi__ + + `__STRING2_SMALL_GET16 + ( +c +, 4), \ + +607 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 0), \ + +608 +__exnsi__ + + `__STRING2_SMALL_GET32 + ( +c +, 4) + + ) + +610 +__STRING_INLINE + * +__py_sml + (*, +__ut16_t +, __uint16_t, + +611 +__ut32_t +, __ut32_t, +size_t +); + +612 +__STRING_INLINE + * + +613 + $__py_sml + (* +__de +, + +614 +__ut16_t + +__c0_2 +, __ut16_ +__c4_2 +, + +615 +__ut32_t + +__c0_4 +, __ut32_ +__c4_4 +, + +616 +size_t + +__ +) + +619  +__ui +; + +620  +__usi +; + +621  +__uc +; + +622  +__c +; + +623 } * +__u + = (* +__de +; + +624 ( +__ +) + +627 +__u +-> +__uc + = '\0'; + +630 +__u +-> +__usi + = +__c0_2 +; + +631 +__u + = + `__exnsi__ + ((*) __u + 1); + +634 +__u +-> +__usi + = +__c0_2 +; + +635 +__u + = + `__exnsi__ + ((*) __u + 2); + +636 +__u +-> +__uc + = '\0'; + +639 +__u +-> +__ui + = +__c0_4 +; + +640 +__u + = + `__exnsi__ + ((*) __u + 3); + +643 +__u +-> +__ui + = +__c0_4 +; + +644 +__u + = + `__exnsi__ + ((*) __u + 4); + +645 +__u +-> +__uc + = '\0'; + +648 +__u +-> +__ui + = +__c0_4 +; + +649 +__u + = + `__exnsi__ + ((*) __u + 4); + +650 +__u +-> +__usi + = +__c4_2 +; + +651 +__u + = + `__exnsi__ + ((*) __u + 1); + +654 +__u +-> +__ui + = +__c0_4 +; + +655 +__u + = + `__exnsi__ + ((*) __u + 4); + +656 +__u +-> +__usi + = +__c4_2 +; + +657 +__u + = + `__exnsi__ + ((*) __u + 2); + +658 +__u +-> +__uc + = '\0'; + +661 +__u +-> +__ui + = +__c0_4 +; + +662 +__u + = + `__exnsi__ + ((*) __u + 4); + +663 +__u +-> +__ui + = +__c4_4 +; + +664 +__u + = + `__exnsi__ + ((*) __u + 3); + +667  & +__u +-> +__c +; + +668 + } +} + +670 #ide +_FORCE_INLINES + + +671  + #__py_gs +( +c +) \ + +672 + `__exnsi__ + (( +__STRING2_COPY_ARR2 +) \ + +673 { { (( +__cڡ + *( +c +))[0], '\0' } }), \ + +674 + `__exnsi__ + (( +__STRING2_COPY_ARR3 +) \ + +675 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +677 + `__exnsi__ + (( +__STRING2_COPY_ARR4 +) \ + +678 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +679 (( +__cڡ + *( +c +))[2], '\0' } }), \ + +680 + `__exnsi__ + (( +__STRING2_COPY_ARR5 +) \ + +681 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +682 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +684 + `__exnsi__ + (( +__STRING2_COPY_ARR6 +) \ + +685 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +686 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +687 (( +__cڡ + *( +c +))[4], '\0' } }), \ + +688 + `__exnsi__ + (( +__STRING2_COPY_ARR7 +) \ + +689 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +690 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +691 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +693 + `__exnsi__ + (( +__STRING2_COPY_ARR8 +) \ + +694 { { (( +__cڡ + *( +c +))[0], ((__const *) (src))[1], \ + +695 (( +__cڡ + *( +c +))[2], ((__const *) (src))[3], \ + +696 (( +__cڡ + *( +c +))[4], ((__const *) (src))[5], \ + +697 (( +__cڡ + *( +c +))[6], '\0' } }) + + ) + +699 +__STRING_INLINE + * +__py_sml + (*, +__STRING2_COPY_ARR2 +, + +700 +__STRING2_COPY_ARR3 +, + +701 +__STRING2_COPY_ARR4 +, + +702 +__STRING2_COPY_ARR5 +, + +703 +__STRING2_COPY_ARR6 +, + +704 +__STRING2_COPY_ARR7 +, + +705 +__STRING2_COPY_ARR8 +, +size_t +); + +706 +__STRING_INLINE + * + +707 + $__py_sml + (* +__de +, + +708 +__STRING2_COPY_ARR2 + +__c2 +, +__STRING2_COPY_ARR3 + +__c3 +, + +709 +__STRING2_COPY_ARR4 + +__c4 +, +__STRING2_COPY_ARR5 + +__c5 +, + +710 +__STRING2_COPY_ARR6 + +__c6 +, +__STRING2_COPY_ARR7 + +__c7 +, + +711 +__STRING2_COPY_ARR8 + +__c8 +, +size_t + +__ +) + +714  +__c +; + +715 +__STRING2_COPY_ARR2 + +__s2 +; + +716 +__STRING2_COPY_ARR3 + +__s3 +; + +717 +__STRING2_COPY_ARR4 + +__s4 +; + +718 +__STRING2_COPY_ARR5 + +__s5 +; + +719 +__STRING2_COPY_ARR6 + +__s6 +; + +720 +__STRING2_COPY_ARR7 + +__s7 +; + +721 +__STRING2_COPY_ARR8 + +__s8 +; + +722 } * +__u + = (* +__de +; + +723 ( +__ +) + +726 +__u +-> +__c + = '\0'; + +729 +__exnsi__ + +__u +-> +__s2 + = +__c2 +; + +732 +__exnsi__ + +__u +-> +__s3 + = +__c3 +; + +735 +__exnsi__ + +__u +-> +__s4 + = +__c4 +; + +738 +__exnsi__ + +__u +-> +__s5 + = +__c5 +; + +741 +__exnsi__ + +__u +-> +__s6 + = +__c6 +; + +744 +__exnsi__ + +__u +-> +__s7 + = +__c7 +; + +747 +__exnsi__ + +__u +-> +__s8 + = +__c8 +; + +750  +__de + + +__ + - 1; + +751 + } +} + +759 #ide +_HAVE_STRING_ARCH_y + + +760 #i +__GNUC_PREREQ + (3, 2) + +761  + #y +( +de +, +c +, +n + + `__but_y + (de, src,) + + ) + +763  + #y +( +de +, +c +, +n +) \ + +764 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +765 ? ( + ` + ( +c ++ 1 >(( +size_t +( +n +)) \ + +766 ? (* + `memy + ( +de +, +c +, +n +) \ + +767 : + `y + ( +de +, +c +, +n +)) \ + +768 : + `y + ( +de +, +c +, +n +))) + + ) + +774 #ide +_HAVE_STRING_ARCH_t + + +775 #ifde +_USE_STRING_ARCH_rchr + + +776  + #t +( +de +, +c +, +n +) \ + +777 ( + `__exnsi__ + ({ * +__de + = ( +de +); \ + +778 + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +779 ? ( + ` + ( +c +< (( +size_t +( +n +)) \ + +780 ? + `rt + ( +__de +, +c +) \ + +781 : (*((* + `__mempy + ( + `rchr + ( +__de +, '\0'), \ + +782 +c +, +n +)'\0', +__de +)) \ + +783 : + `t + ( +de +, +c +, +n +); })) + + ) + +784 #i +__GNUC_PREREQ + (3, 2) + +785  + #t +( +de +, +c +, +n + + `__but_t + (de, src,) + + ) + +787  + #t +( +de +, +c +, +n +) \ + +788 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +c +&& __but_cڡt_( +n +) \ + +789 ? ( + ` + ( +c +< (( +size_t +( +n +)) \ + +790 ? + `rt + ( +de +, +c +) \ + +791 : + `t + ( +de +, +c +, +n +)) \ + +792 : + `t + ( +de +, +c +, +n +))) + + ) + +798 #ide +_HAVE_STRING_ARCH_rcmp + + +799 #i +__GNUC_PREREQ + (3, 2) + +800  + #rcmp +( +s1 +, +s2 +) \ + +801 +__exnsi__ + \ + +802 ({ +size_t + +__s1_n +, +__s2_n +; \ + +803 ( + `__but_cڡt_p + ( +s1 +&& __but_cڡt_( +s2 +) \ + +804 && ( +__s1_n + = + ` + ( +s1 +), +__s2_n + = s( +s2 +), \ + +805 (! + `__rg2_1br_p + ( +s1 +|| +__s1_n + >= 4) \ + +806 && (! + `__rg2_1br_p + ( +s2 +|| +__s2_n + >= 4)) \ + +807 ? + `__but_rcmp + ( +s1 +, +s2 +) \ + +808 : ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +809 && ( +__s1_n + = + ` + ( +s1 +), __s1_len < 4) \ + +810 ? ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +811 ? + `__but_rcmp + ( +s1 +, +s2 +) \ + +812 : + `__rcmp_cg + ( +s1 +, +s2 +, +__s1_n +)) \ + +813 : ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +814 && ( +__s2_n + = + ` + ( +s2 +), __s2_len < 4) \ + +815 ? ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +816 ? + `__but_rcmp + ( +s1 +, +s2 +) \ + +817 : + `__rcmp_gc + ( +s1 +, +s2 +, +__s2_n +)) \ + +818 : + `__but_rcmp + ( +s1 +, +s2 +)))); }) + + ) + +820  + #rcmp +( +s1 +, +s2 +) \ + +821 +__exnsi__ + \ + +822 ({ +size_t + +__s1_n +, +__s2_n +; \ + +823 ( + `__but_cڡt_p + ( +s1 +&& __but_cڡt_( +s2 +) \ + +824 && ( +__s1_n + = + ` + ( +s1 +), +__s2_n + = s( +s2 +), \ + +825 (! + `__rg2_1br_p + ( +s1 +|| +__s1_n + >= 4) \ + +826 && (! + `__rg2_1br_p + ( +s2 +|| +__s2_n + >= 4)) \ + +827 ? + `memcmp + (( +__cڡ + *( +s1 +), (__cڡ *( +s2 +), \ + +828 ( +__s1_n + < +__s2_n + ? __s1_len : __s2_len) + 1) \ + +829 : ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +830 && ( +__s1_n + = + ` + ( +s1 +), __s1_len < 4) \ + +831 ? ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +832 ? + `__rcmp_cc + ( +s1 +, +s2 +, +__s1_n +) \ + +833 : + `__rcmp_cg + ( +s1 +, +s2 +, +__s1_n +)) \ + +834 : ( + `__but_cڡt_p + ( +s2 +&& + `__rg2_1br_p + (s2) \ + +835 && ( +__s2_n + = + ` + ( +s2 +), __s2_len < 4) \ + +836 ? ( + `__but_cڡt_p + ( +s1 +&& + `__rg2_1br_p + (s1) \ + +837 ? + `__rcmp_cc + ( +s1 +, +s2 +, +__s2_n +) \ + +838 : + `__rcmp_gc + ( +s1 +, +s2 +, +__s2_n +)) \ + +839 : + `rcmp + ( +s1 +, +s2 +)))); }) + + ) + +842  + #__rcmp_cc +( +s1 +, +s2 +, +l +) \ + +843 ( + `__exnsi__ + ({  +__su + = \ + +844 ((( +__cڡ + *(__cڡ *( +s1 +))[0] \ + +845 - (( +__cڡ + *(__cڡ *)( +s2 +))[0]);\ + +846 i( +l + > 0 && +__su + == 0) \ + +848 +__su + = ((( +__cڡ + *) \ + +849 ( +__cڡ + *( +s1 +))[1] \ + +850 - (( +__cڡ + *) \ + +851 ( +__cڡ + *( +s2 +))[1]); \ + +852 i( +l + > 1 && +__su + == 0) \ + +854 +__su + = \ + +855 ((( +__cڡ + *) \ + +856 ( +__cڡ + *( +s1 +))[2] \ + +857 - (( +__cڡ + *) \ + +858 ( +__cڡ + *( +s2 +))[2]); \ + +859 i( +l + > 2 && +__su + == 0) \ + +860 +__su + = \ + +861 ((( +__cڡ + *) \ + +862 ( +__cڡ + *( +s1 +))[3] \ + +863 - (( +__cڡ + *) \ + +864 ( +__cڡ + *( +s2 +))[3]); \ + +867 +__su +; })) + + ) + +869  + #__rcmp_cg +( +s1 +, +s2 +, +l1 +) \ + +870 ( + `__exnsi__ + ({ +__cڡ + * +__s2 + = \ + +871 ( +__cڡ + *(__cڡ *( +s2 +); \ + +872  +__su + = \ + +873 ((( +__cڡ + *(__cڡ *( +s1 +))[0] \ + +874 - +__s2 +[0]); \ + +875 i( +l1 + > 0 && +__su + == 0) \ + +877 +__su + = ((( +__cڡ + *) \ + +878 ( +__cڡ + *( +s1 +))[1] - +__s2 +[1]); \ + +879 i( +l1 + > 1 && +__su + == 0) \ + +881 +__su + = ((( +__cڡ + *) \ + +882 ( +__cڡ + *( +s1 +))[2] - +__s2 +[2]);\ + +883 i( +l1 + > 2 && +__su + == 0) \ + +884 +__su + = ((( +__cڡ + *) \ + +885 ( +__cڡ + *( +s1 +))[3] \ + +886 - +__s2 +[3]); \ + +889 +__su +; })) + + ) + +891  + #__rcmp_gc +( +s1 +, +s2 +, +l2 +) \ + +892 ( + `__exnsi__ + ({ +__cڡ + * +__s1 + = \ + +893 ( +__cڡ + *(__cڡ *( +s1 +); \ + +894  +__su + = \ + +895 +__s1 +[0] - (( +__cڡ + *) \ + +896 ( +__cڡ + *( +s2 +))[0]; \ + +897 i( +l2 + > 0 && +__su + == 0) \ + +899 +__su + = ( +__s1 +[1] \ + +900 - (( +__cڡ + *) \ + +901 ( +__cڡ + *( +s2 +))[1]); \ + +902 i( +l2 + > 1 && +__su + == 0) \ + +904 +__su + = \ + +905 ( +__s1 +[2] - (( +__cڡ + *) \ + +906 ( +__cڡ + *( +s2 +))[2]); \ + +907 i( +l2 + > 2 && +__su + == 0) \ + +908 +__su + = \ + +909 ( +__s1 +[3] \ + +910 - (( +__cڡ + *) \ + +911 ( +__cڡ + *( +s2 +))[3]); \ + +914 +__su +; })) + + ) + +919 #ide +_HAVE_STRING_ARCH_cmp + + +920  + #cmp +( +s1 +, +s2 +, +n +) \ + +921 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +n +) \ + +922 && (( + `__but_cڡt_p + ( +s1 +) \ + +923 && + ` + ( +s1 +< (( +size_t +( +n +))) \ + +924 || ( + `__but_cڡt_p + ( +s2 +) \ + +925 && + ` + ( +s2 +< (( +size_t +( +n +)))) \ + +926 ? + `rcmp + ( +s1 +, +s2 +: + `cmp + (s1, s2, +n +))) + + ) + +932 #i! +defed + +_HAVE_STRING_ARCH_rcn + || defed +_FORCE_INLINES + + +933 #ide +_HAVE_STRING_ARCH_rcn + + +934 #i +__GNUC_PREREQ + (3, 2) + +935  + #rcn +( +s +, +je +) \ + +936 +__exnsi__ + \ + +937 ({  +__r0 +, +__r1 +, +__r2 +; \ + +938 ( + `__but_cڡt_p + ( +je +&& + `__rg2_1br_p + (reject) \ + +939 ? (( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s)) \ + +940 ? + `__but_rcn + ( +s +, +je +) \ + +941 : (( +__r0 + = (( +__cڡ + *( +je +))[0], __r0 == '\0') \ + +942 ? + ` + ( +s +) \ + +943 : (( +__r1 + = (( +__cڡ + *( +je +))[1], __r1 == '\0') \ + +944 ? + `__rcn_c1 + ( +s +, +__r0 +) \ + +945 : (( +__r2 + = (( +__cڡ + *( +je +))[2], __r2 == '\0') \ + +946 ? + `__rcn_c2 + ( +s +, +__r0 +, +__r1 +) \ + +947 : ((( +__cڡ + *( +je +))[3] == '\0' \ + +948 ? + `__rcn_c3 + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +949 : + `__but_rcn + ( +s +, +je +)))))) \ + +950 : + `__but_rcn + ( +s +, +je +)); }) + + ) + +952  + #rcn +( +s +, +je +) \ + +953 +__exnsi__ + \ + +954 ({  +__r0 +, +__r1 +, +__r2 +; \ + +955 ( + `__but_cڡt_p + ( +je +&& + `__rg2_1br_p + (reject) \ + +956 ? (( +__r0 + = (( +__cڡ + *( +je +))[0], __r0 == '\0') \ + +957 ? + ` + ( +s +) \ + +958 : (( +__r1 + = (( +__cڡ + *( +je +))[1], __r1 == '\0') \ + +959 ? + `__rcn_c1 + ( +s +, +__r0 +) \ + +960 : (( +__r2 + = (( +__cڡ + *( +je +))[2], __r2 == '\0') \ + +961 ? + `__rcn_c2 + ( +s +, +__r0 +, +__r1 +) \ + +962 : ((( +__cڡ + *( +je +))[3] == '\0' \ + +963 ? + `__rcn_c3 + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +964 : + `rcn + ( +s +, +je +))))) \ + +965 : + `rcn + ( +s +, +je +)); }) + + ) + +969 +__STRING_INLINE + +size_t + +__rcn_c1 + ( +__cڡ + * +__s +,  +__je +); + +970 +__STRING_INLINE + +size_t + + +971 + $__rcn_c1 + ( +__cڡ + * +__s +,  +__je +) + +973  +size_t + +__su + = 0; + +974  +__s +[ +__su +] !'\0' && __s[__su] ! +__je +) + +975 ++ +__su +; + +976  +__su +; + +977 + } +} + +979 +__STRING_INLINE + +size_t + +__rcn_c2 + ( +__cڡ + * +__s +,  +__je1 +, + +980  +__je2 +); + +981 +__STRING_INLINE + +size_t + + +982 + $__rcn_c2 + ( +__cڡ + * +__s +,  +__je1 +,  +__je2 +) + +984  +size_t + +__su + = 0; + +985  +__s +[ +__su +] !'\0' && __s[__su] ! +__je1 + + +986 && +__s +[ +__su +] ! +__je2 +) + +987 ++ +__su +; + +988  +__su +; + +989 + } +} + +991 +__STRING_INLINE + +size_t + +__rcn_c3 + ( +__cڡ + * +__s +,  +__je1 +, + +992  +__je2 +,  +__je3 +); + +993 +__STRING_INLINE + +size_t + + +994 + $__rcn_c3 + ( +__cڡ + * +__s +,  +__je1 +,  +__je2 +, + +995  +__je3 +) + +997  +size_t + +__su + = 0; + +998  +__s +[ +__su +] !'\0' && __s[__su] ! +__je1 + + +999 && +__s +[ +__su +] ! +__je2 + && __s[__su] ! +__je3 +) + +1000 ++ +__su +; + +1001  +__su +; + +1002 + } +} + +1008 #i! +defed + +_HAVE_STRING_ARCH_rn + || defed +_FORCE_INLINES + + +1009 #ide +_HAVE_STRING_ARCH_rn + + +1010 #i +__GNUC_PREREQ + (3, 2) + +1011  + #rn +( +s +, +ac +) \ + +1012 +__exnsi__ + \ + +1013 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1014 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1015 ? (( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s)) \ + +1016 ? + `__but_rn + ( +s +, +ac +) \ + +1017 : (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1018 ? ((( +s +), 0) \ + +1019 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1020 ? + `__rn_c1 + ( +s +, +__a0 +) \ + +1021 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1022 ? + `__rn_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1023 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1024 ? + `__rn_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1025 : + `__but_rn + ( +s +, +ac +)))))) \ + +1026 : + `__but_rn + ( +s +, +ac +)); }) + + ) + +1028  + #rn +( +s +, +ac +) \ + +1029 +__exnsi__ + \ + +1030 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1031 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1032 ? (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1033 ? ((( +s +), 0) \ + +1034 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1035 ? + `__rn_c1 + ( +s +, +__a0 +) \ + +1036 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1037 ? + `__rn_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1038 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1039 ? + `__rn_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1040 : + `rn + ( +s +, +ac +))))) \ + +1041 : + `rn + ( +s +, +ac +)); }) + + ) + +1045 +__STRING_INLINE + +size_t + +__rn_c1 + ( +__cڡ + * +__s +,  +__ac +); + +1046 +__STRING_INLINE + +size_t + + +1047 + $__rn_c1 + ( +__cڡ + * +__s +,  +__ac +) + +1049  +size_t + +__su + = 0; + +1051  +__s +[ +__su +] = +__ac +) + +1052 ++ +__su +; + +1053  +__su +; + +1054 + } +} + +1056 +__STRING_INLINE + +size_t + +__rn_c2 + ( +__cڡ + * +__s +,  +__ac1 +, + +1057  +__ac2 +); + +1058 +__STRING_INLINE + +size_t + + +1059 + $__rn_c2 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +) + +1061  +size_t + +__su + = 0; + +1063  +__s +[ +__su +] = +__ac1 + || __s[__su] = +__ac2 +) + +1064 ++ +__su +; + +1065  +__su +; + +1066 + } +} + +1068 +__STRING_INLINE + +size_t + +__rn_c3 + ( +__cڡ + * +__s +,  +__ac1 +, + +1069  +__ac2 +,  +__ac3 +); + +1070 +__STRING_INLINE + +size_t + + +1071 + $__rn_c3 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +,  +__ac3 +) + +1073  +size_t + +__su + = 0; + +1075  +__s +[ +__su +] = +__ac1 + || __s[__su] = +__ac2 + + +1076 || +__s +[ +__su +] = +__ac3 +) + +1077 ++ +__su +; + +1078  +__su +; + +1079 + } +} + +1084 #i! +defed + +_HAVE_STRING_ARCH_brk + || defed +_FORCE_INLINES + + +1085 #ide +_HAVE_STRING_ARCH_brk + + +1086 #i +__GNUC_PREREQ + (3, 2) + +1087  + #brk +( +s +, +ac +) \ + +1088 +__exnsi__ + \ + +1089 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1090 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1091 ? (( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s)) \ + +1092 ? + `__but_brk + ( +s +, +ac +) \ + +1093 : (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1094 ? ((( +s +), (* +NULL +) \ + +1095 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1096 ? + `__but_rchr + ( +s +, +__a0 +) \ + +1097 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1098 ? + `__brk_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1099 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1100 ? + `__brk_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1101 : + `__but_brk + ( +s +, +ac +)))))) \ + +1102 : + `__but_brk + ( +s +, +ac +)); }) + + ) + +1104  + #brk +( +s +, +ac +) \ + +1105 +__exnsi__ + \ + +1106 ({  +__a0 +, +__a1 +, +__a2 +; \ + +1107 ( + `__but_cڡt_p + ( +ac +&& + `__rg2_1br_p + (accept) \ + +1108 ? (( +__a0 + = (( +__cڡ + *( +ac +))[0], __a0 == '\0') \ + +1109 ? ((( +s +), (* +NULL +) \ + +1110 : (( +__a1 + = (( +__cڡ + *( +ac +))[1], __a1 == '\0') \ + +1111 ? + `rchr + ( +s +, +__a0 +) \ + +1112 : (( +__a2 + = (( +__cڡ + *( +ac +))[2], __a2 == '\0') \ + +1113 ? + `__brk_c2 + ( +s +, +__a0 +, +__a1 +) \ + +1114 : ((( +__cڡ + *( +ac +))[3] == '\0' \ + +1115 ? + `__brk_c3 + ( +s +, +__a0 +, +__a1 +, +__a2 +) \ + +1116 : + `brk + ( +s +, +ac +))))) \ + +1117 : + `brk + ( +s +, +ac +)); }) + + ) + +1121 +__STRING_INLINE + * +__brk_c2 + ( +__cڡ + * +__s +,  +__ac1 +, + +1122  +__ac2 +); + +1123 +__STRING_INLINE + * + +1124 + $__brk_c2 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +) + +1127 * +__s + !'\0' && *__! +__ac1 + && *__! +__ac2 +) + +1128 ++ +__s +; + +1129  * +__s + ='\0' ? +NULL + : (*( +size_t +) __s; + +1130 + } +} + +1132 +__STRING_INLINE + * +__brk_c3 + ( +__cڡ + * +__s +,  +__ac1 +, + +1133  +__ac2 +,  +__ac3 +); + +1134 +__STRING_INLINE + * + +1135 + $__brk_c3 + ( +__cڡ + * +__s +,  +__ac1 +,  +__ac2 +, + +1136  +__ac3 +) + +1139 * +__s + !'\0' && *__! +__ac1 + && *__! +__ac2 + + +1140 && * +__s + ! +__ac3 +) + +1141 ++ +__s +; + +1142  * +__s + ='\0' ? +NULL + : (*( +size_t +) __s; + +1143 + } +} + +1149 #i! +defed + +_HAVE_STRING_ARCH_rr + && ! +__GNUC_PREREQ + (2, 97) + +1150  + #rr +( +hayack +, +ed +) \ + +1151 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +ed +&& + `__rg2_1br_p + (needle) \ + +1152 ? ((( +__cڡ + *( +ed +))[0] == '\0' \ + +1153 ? (*( +size_t +( +hayack +) \ + +1154 : ((( +__cڡ + *( +ed +))[1] == '\0' \ + +1155 ? + `rchr + ( +hayack +, \ + +1156 (( +__cڡ + *( +ed +))[0]) \ + +1157 : + `rr + ( +hayack +, +ed +))) \ + +1158 : + `rr + ( +hayack +, +ed +))) + + ) + +1162 #i! +defed + +_HAVE_STRING_ARCH_ok_r + || defed +_FORCE_INLINES + + +1163 #ide +_HAVE_STRING_ARCH_ok_r + + +1164  + #__ok_r +( +s +, +p +, +x +) \ + +1165 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +p +&& + `__rg2_1br_p + (sep) \ + +1166 && (( +__cڡ + *( +p +))[0] != '\0' \ + +1167 && (( +__cڡ + *( +p +))[1] == '\0' \ + +1168 ? + `__ok_r_1c + ( +s +, (( +__cڡ + *( +p +))[0], +x +) \ + +1169 : + `__ok_r + ( +s +, +p +, +x +))) + + ) + +1172 +__STRING_INLINE + * +__ok_r_1c + (* +__s +,  +__p +, ** +__x +); + +1173 +__STRING_INLINE + * + +1174 + $__ok_r_1c + (* +__s +,  +__p +, ** +__x +) + +1176 * +__su +; + +1177 i( +__s + = +NULL +) + +1178 +__s + = * +__x +; + +1179 * +__s + = +__p +) + +1180 ++ +__s +; + +1181 +__su + = +NULL +; + +1182 i(* +__s + != '\0') + +1184 +__su + = +__s +++; + +1185 * +__s + != '\0') + +1186 i(* +__s +++ = +__p +) + +1188 +__s +[-1] = '\0'; + +1192 * +__x + = +__s +; + +1193  +__su +; + +1194 + } +} + +1195 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +1196  + #ok_r +( +s +, +p +, +x + + `__ok_r + (s, s,ex) + + ) + +1201 #i! +defed + +_HAVE_STRING_ARCH_rp + || defed +_FORCE_INLINES + + +1202 #ide +_HAVE_STRING_ARCH_rp + + +1204 * +__rp_g + (** +__rgp +, +__cڡ + * +__dim +); + +1205  + #__rp +( +s +, +je +) \ + +1206 +__exnsi__ + \ + +1207 ({  +__r0 +, +__r1 +, +__r2 +; \ + +1208 ( + `__but_cڡt_p + ( +je +&& + `__rg2_1br_p + (reject) \ + +1209 && ( +__r0 + = (( +__cڡ + *( +je +))[0], \ + +1210 (( +__cڡ + *( +je +))[0] != '\0') \ + +1211 ? (( +__r1 + = (( +__cڡ + *( +je +))[1], \ + +1212 (( +__cڡ + *( +je +))[1] == '\0') \ + +1213 ? + `__rp_1c + ( +s +, +__r0 +) \ + +1214 : (( +__r2 + = (( +__cڡ + *( +je +))[2], __r2 == '\0') \ + +1215 ? + `__rp_2c + ( +s +, +__r0 +, +__r1 +) \ + +1216 : ((( +__cڡ + *( +je +))[3] == '\0' \ + +1217 ? + `__rp_3c + ( +s +, +__r0 +, +__r1 +, +__r2 +) \ + +1218 : + `__rp_g + ( +s +, +je +)))) \ + +1219 : + `__rp_g + ( +s +, +je +)); }) + + ) + +1222 +__STRING_INLINE + * +__rp_1c + (** +__s +,  +__je +); + +1223 +__STRING_INLINE + * + +1224 + $__rp_1c + (** +__s +,  +__je +) + +1226 * +__tv + = * +__s +; + +1227 i( +__tv + ! +NULL + && (* +__s + = + `rchr + (__tv, +__je +)) != NULL) + +1228 *(* +__s +)++ = '\0'; + +1229  +__tv +; + +1230 + } +} + +1232 +__STRING_INLINE + * +__rp_2c + (** +__s +,  +__je1 +,  +__je2 +); + +1233 +__STRING_INLINE + * + +1234 + $__rp_2c + (** +__s +,  +__je1 +,  +__je2 +) + +1236 * +__tv + = * +__s +; + +1237 i( +__tv + ! +NULL +) + +1239 * +__ + = +__tv +; + +1242 i(* +__ + == '\0') + +1244 +__ + = +NULL +; + +1247 i(* +__ + = +__je1 + || *__ = +__je2 +) + +1249 * +__ +++ = '\0'; + +1252 ++ +__ +; + +1254 * +__s + = +__ +; + +1256  +__tv +; + +1257 + } +} + +1259 +__STRING_INLINE + * +__rp_3c + (** +__s +,  +__je1 +,  +__je2 +, + +1260  +__je3 +); + +1261 +__STRING_INLINE + * + +1262 + $__rp_3c + (** +__s +,  +__je1 +,  +__je2 +,  +__je3 +) + +1264 * +__tv + = * +__s +; + +1265 i( +__tv + ! +NULL +) + +1267 * +__ + = +__tv +; + +1270 i(* +__ + == '\0') + +1272 +__ + = +NULL +; + +1275 i(* +__ + = +__je1 + || *__ = +__je2 + || *__ = +__je3 +) + +1277 * +__ +++ = '\0'; + +1280 ++ +__ +; + +1282 * +__s + = +__ +; + +1284  +__tv +; + +1285 + } +} + +1286 #ifde +__USE_BSD + + +1287  + #rp +( +s +, +je + + `__rp + (s,eje) + + ) + +1294 #ifde +__USE_MISC + + +1296 #i! +defed + +_HAVE_STRING_ARCH_rdup + || !defed +_HAVE_STRING_ARCH_dup + + +1297  + #__ed_mloc_d_oc + + + ) + +1298  + ~ + +1301 #ide +_HAVE_STRING_ARCH_rdup + + +1303 * + $__rdup + ( +__cڡ + * +__rg + +__THROW + +__ibu_mloc__ +; + +1304  + #__rdup +( +s +) \ + +1305 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s) \ + +1306 ? ((( +__cڡ + *( +s +))[0] == '\0' \ + +1307 ? (* + `oc + (( +size_t +) 1, (size_t) 1) \ + +1308 : ({ +size_t + +__n + = + ` + ( +s +) + 1; \ + +1309 * +__tv + = (* + `mloc + ( +__n +); \ + +1310 i( +__tv + ! +NULL +) \ + +1311 +__tv + = (* + `memy + (__tv, +s +, +__n +); \ + +1312 +__tv +; + } +})) \ + +1313 : + `__rdup + ( +s +))) + + ) + +1315 #i +defed + +__USE_SVID + || defed +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +1316  + #rdup +( +s + + `__rdup + (s) + + ) + +1320 #ide +_HAVE_STRING_ARCH_dup + + +1322 * + $__dup + ( +__cڡ + * +__rg +, +size_t + +__n +) + +1323 +__THROW + +__ibu_mloc__ +; + +1324  + #__dup +( +s +, +n +) \ + +1325 ( + `__exnsi__ + ( + `__but_cڡt_p + ( +s +&& + `__rg2_1br_p + (s) \ + +1326 ? ((( +__cڡ + *( +s +))[0] == '\0' \ + +1327 ? (* + `oc + (( +size_t +) 1, (size_t) 1) \ + +1328 : ({ +size_t + +__n + = + ` + ( +s +) + 1; \ + +1329 +size_t + +__n + = ( +n +); \ + +1330 * +__tv +; \ + +1331 i( +__n + < +__n +) \ + +1332 +__n + = +__n + + 1; \ + +1333 +__tv + = (* + `mloc + ( +__n +); \ + +1334 i( +__tv + ! +NULL +) \ + +1336 +__tv +[ +__n + - 1] = '\0'; \ + +1337 +__tv + = (* + `memy + (__tv, +s +, \ + +1338 +__n + - 1); \ + +1340 +__tv +; + } +})) \ + +1341 : + `__dup + ( +s +, +n +))) + + ) + +1343 #ifde +__USE_GNU + + +1344  + #dup +( +s +, +n + + `__dup + (s,) + + ) + +1350 #ide +_FORCE_INLINES + + +1351 #unde +__STRING_INLINE + + + @/usr/include/bits/string3.h + +19 #ide +_STRING_H + + +23 +__wnde + ( +__wn_memt_zo_n +, + +26 #ide +__lulus + + +30 #unde +memy + + +31 #unde +memmove + + +32 #unde +memt + + +33 #unde +rt + + +34 #unde +ry + + +35 #unde +t + + +36 #unde +y + + +37 #ifde +__USE_GNU + + +38 #unde +mempy + + +39 #unde +py + + +41 #ifde +__USE_BSD + + +42 #unde +bcy + + +43 #unde +bzo + + +48 +__ex_ways_le + * + +49 +__NTH + ( + $memy + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +50 +size_t + +__n +)) + +52  + `__but___memy_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +53 + } +} + +55 +__ex_ways_le + * + +56 +__NTH + ( + $memmove + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +57 +size_t + +__n +)) + +59  + `__but___memmove_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +60 + } +} + +62 #ifde +__USE_GNU + + +63 +__ex_ways_le + * + +64 +__NTH + ( + $mempy + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +65 +size_t + +__n +)) + +67  + `__but___mempy_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +68 + } +} + +77 +__ex_ways_le + * + +78 +__NTH + ( + $memt + (* +__de +,  +__ch +, +size_t + +__n +)) + +80 i( + `__but_cڡt_p + ( +__n +) && __len == 0 + +81 && (! + `__but_cڡt_p + ( +__ch +) || __ch != 0)) + +83 + `__wn_memt_zo_n + (); + +84  +__de +; + +86  + `__but___memt_chk + ( +__de +, +__ch +, +__n +, + `__bos0 + (__dest)); + +87 + } +} + +89 #ifde +__USE_BSD + + +90 +__ex_ways_le +  + +91 +__NTH + ( + $bcy + ( +__cڡ + * +__ri + +__c +, *__ri +__de +, + +92 +size_t + +__n +)) + +94 ( + `__but___memmove_chk + ( +__de +, +__c +, +__n +, + `__bos0 + (__dest)); + +95 + } +} + +97 +__ex_ways_le +  + +98 +__NTH + ( + $bzo + (* +__de +, +size_t + +__n +)) + +100 ( + `__but___memt_chk + ( +__de +, '\0', +__n +, + `__bos0 + (__dest)); + +101 + } +} + +104 +__ex_ways_le + * + +105 +__NTH + ( + $ry + (* +__ri + +__de +, +__cڡ + *__ri +__c +)) + +107  + `__but___ry_chk + ( +__de +, +__c +, + `__bos + (__dest)); + +108 + } +} + +110 #ifde +__USE_GNU + + +111 +__ex_ways_le + * + +112 +__NTH + ( + $py + (* +__ri + +__de +, +__cڡ + *__ri +__c +)) + +114  + `__but___py_chk + ( +__de +, +__c +, + `__bos + (__dest)); + +115 + } +} + +119 +__ex_ways_le + * + +120 +__NTH + ( + $y + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +121 +size_t + +__n +)) + +123  + `__but___y_chk + ( +__de +, +__c +, +__n +, + `__bos + (__dest)); + +124 + } +} + +127 * + $__y_chk + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +, + +128 +size_t + +__den + +__THROW +; + +129 * + `__REDIRECT_NTH + ( +__y_s +, (* +__de +, + +130 +__cڡ + * +__c +, + +131 +size_t + +__n +), +y +); + +133 +__ex_ways_le + * + +134 + `__NTH + ( + $y + (* +__de +, +__cڡ + * +__c +, +size_t + +__n +)) + +136 i( + `__bos + ( +__de +!( +size_t +) -1 + +137 && (! + `__but_cڡt_p + ( +__n +|| __< + `__bos + ( +__de +))) + +138  + `__y_chk + ( +__de +, +__c +, +__n +, + `__bos + (__dest)); + +139  + `__y_s + ( +__de +, +__c +, +__n +); + +140 + } +} + +143 +__ex_ways_le + * + +144 +__NTH + ( + $rt + (* +__ri + +__de +, +__cڡ + *__ri +__c +)) + +146  + `__but___rt_chk + ( +__de +, +__c +, + `__bos + (__dest)); + +147 + } +} + +150 +__ex_ways_le + * + +151 +__NTH + ( + $t + (* +__ri + +__de +, +__cڡ + *__ri +__c +, + +152 +size_t + +__n +)) + +154  + `__but___t_chk + ( +__de +, +__c +, +__n +, + `__bos + (__dest)); + +155 + } +} + + @/usr/include/bits/sys_errlist.h + +20 #ide +_STDIO_H + + +26 #ifde +__USE_BSD + + +27  +sys_ü +; + +28 +__cڡ + *__cڡ +sys_i +[]; + +30 #ifde +__USE_GNU + + +31  +_sys_ü +; + +32 +__cڡ + *__cڡ +_sys_i +[]; + + @/usr/include/bits/types.h + +24 #idef +_BITS_TYPES_H + + +25  + #_BITS_TYPES_H + 1 + + ) + +27  + ~ + +28  + ~ + +31  + t__u_ch +; + +32  + t__u_sht +; + +33  + t__u_t +; + +34  + t__u_lg +; + +37 sigd  + t__t8_t +; + +38  + t__ut8_t +; + +39 sigd  + t__t16_t +; + +40  + t__ut16_t +; + +41 sigd  + t__t32_t +; + +42  + t__ut32_t +; + +43 #i +__WORDSIZE + == 64 + +44 sigd  + t__t64_t +; + +45  + t__ut64_t +; + +46 #i +defed + +__GLIBC_HAVE_LONG_LONG + + +47 +__exnsi__ + sigd  + t__t64_t +; + +48 +__exnsi__ +  + t__ut64_t +; + +52 #i +__WORDSIZE + == 64 + +53  + t__quad_t +; + +54  + t__u_quad_t +; + +55 #i +defed + +__GLIBC_HAVE_LONG_LONG + + +56 +__exnsi__ +  + t__quad_t +; + +57 +__exnsi__ +  + t__u_quad_t +; + +61  + m__v +[2]; + +62 } + t__quad_t +; + +65 +__u_lg + + m__v +[2]; + +66 } + t__u_quad_t +; + +99  + #__S16_TYPE +  + + ) + +100  + #__U16_TYPE +  + + ) + +101  + #__S32_TYPE +  + + ) + +102  + #__U32_TYPE +  + + ) + +103  + #__SLONGWORD_TYPE +  + + ) + +104  + #__ULONGWORD_TYPE +  + + ) + +105 #i +__WORDSIZE + == 32 + +106  + #__SQUAD_TYPE + +__quad_t + + + ) + +107  + #__UQUAD_TYPE + +__u_quad_t + + + ) + +108  + #__SWORD_TYPE +  + + ) + +109  + #__UWORD_TYPE +  + + ) + +110  + #__SLONG32_TYPE +  + + ) + +111  + #__ULONG32_TYPE +  + + ) + +112  + #__S64_TYPE + +__quad_t + + + ) + +113  + #__U64_TYPE + +__u_quad_t + + + ) + +116  + #__STD_TYPE + +__exnsi__ +  + + ) + +117 #i +__WORDSIZE + == 64 + +118  + t__SQUAD_TYPE +  + + ) + +119  + t__UQUAD_TYPE +  + + ) + +120  + t__SWORD_TYPE +  + + ) + +121  + t__UWORD_TYPE +  + + ) + +122  + t__SLONG32_TYPE +  + + ) + +123  + t__ULONG32_TYPE +  + + ) + +124  + t__S64_TYPE +  + + ) + +125  + t__U64_TYPE +  + + ) + +127  + t__STD_TYPE +  + + ) + +131  + ~ + +134 +__STD_TYPE + + t__DEV_T_TYPE + + t__dev_t +; + +135 +__STD_TYPE + +__UID_T_TYPE + + g__uid_t +; + +136 +__STD_TYPE + +__GID_T_TYPE + + g__gid_t +; + +137 +__STD_TYPE + +__INO_T_TYPE + + g__o_t +; + +138 +__STD_TYPE + +__INO64_T_TYPE + + g__o64_t +; + +139 +__STD_TYPE + +__MODE_T_TYPE + + g__mode_t +; + +140 +__STD_TYPE + +__NLINK_T_TYPE + + g__ƚk_t +; + +141 +__STD_TYPE + +__OFF_T_TYPE + + g__off_t +; + +142 +__STD_TYPE + +__OFF64_T_TYPE + + g__off64_t +; + +143 +__STD_TYPE + +__PID_T_TYPE + + g__pid_t +; + +144 +__STD_TYPE + +__FSID_T_TYPE + + g__fsid_t +; + +145 +__STD_TYPE + +__CLOCK_T_TYPE + + g__ock_t +; + +146 +__STD_TYPE + +__RLIM_T_TYPE + + g__im_t +; + +147 +__STD_TYPE + +__RLIM64_T_TYPE + + g__im64_t +; + +148 +__STD_TYPE + +__ID_T_TYPE + + g__id_t +; + +149 +__STD_TYPE + +__TIME_T_TYPE + + g__time_t +; + +150 +__STD_TYPE + +__USECONDS_T_TYPE + + g__ucds_t +; + +151 +__STD_TYPE + +__SUSECONDS_T_TYPE + + g__sucds_t +; + +153 +__STD_TYPE + +__DADDR_T_TYPE + + g__daddr_t +; + +154 +__STD_TYPE + +__SWBLK_T_TYPE + + g__swblk_t +; + +155 +__STD_TYPE + +__KEY_T_TYPE + + g__key_t +; + +158 +__STD_TYPE + +__CLOCKID_T_TYPE + + g__ockid_t +; + +161 +__STD_TYPE + +__TIMER_T_TYPE + + g__tim_t +; + +164 +__STD_TYPE + +__BLKSIZE_T_TYPE + + g__blksize_t +; + +169 +__STD_TYPE + +__BLKCNT_T_TYPE + + g__blkt_t +; + +170 +__STD_TYPE + +__BLKCNT64_T_TYPE + + g__blkt64_t +; + +173 +__STD_TYPE + +__FSBLKCNT_T_TYPE + + g__fsblkt_t +; + +174 +__STD_TYPE + +__FSBLKCNT64_T_TYPE + + g__fsblkt64_t +; + +177 +__STD_TYPE + +__FSFILCNT_T_TYPE + + g__fsft_t +; + +178 +__STD_TYPE + +__FSFILCNT64_T_TYPE + + g__fsft64_t +; + +180 +__STD_TYPE + +__SSIZE_T_TYPE + + g__ssize_t +; + +184  +__off64_t + + t__loff_t +; + +185  +__quad_t + * + t__qaddr_t +; + +186 * + t__ddr_t +; + +189 +__STD_TYPE + +__SWORD_TYPE + + g___t +; + +192 +__STD_TYPE + +__U32_TYPE + + g__sockn_t +; + +195 #unde +__STD_TYPE + + + @/usr/include/features.h + +19 #idef +_FEATURES_H + + +20  + #_FEATURES_H + 1 + + ) + +95 #unde +__USE_ISOC99 + + +96 #unde +__USE_ISOC95 + + +97 #unde +__USE_POSIX + + +98 #unde +__USE_POSIX2 + + +99 #unde +__USE_POSIX199309 + + +100 #unde +__USE_POSIX199506 + + +101 #unde +__USE_XOPEN + + +102 #unde +__USE_XOPEN_EXTENDED + + +103 #unde +__USE_UNIX98 + + +104 #unde +__USE_XOPEN2K + + +105 #unde +__USE_XOPEN2K8 + + +106 #unde +__USE_LARGEFILE + + +107 #unde +__USE_LARGEFILE64 + + +108 #unde +__USE_FILE_OFFSET64 + + +109 #unde +__USE_BSD + + +110 #unde +__USE_SVID + + +111 #unde +__USE_MISC + + +112 #unde +__USE_ATFILE + + +113 #unde +__USE_GNU + + +114 #unde +__USE_REENTRANT + + +115 #unde +__USE_FORTIFY_LEVEL + + +116 #unde +__FAVOR_BSD + + +117 #unde +__KERNEL_STRICT_NAMES + + +121 #ide +_LOOSE_KERNEL_NAMES + + +122  + #__KERNEL_STRICT_NAMES + + + ) + +126  + #__USE_ANSI + 1 + + ) + +135 #i +defed + +__GNUC__ + && defed +__GNUC_MINOR__ + + +136  + #__GNUC_PREREQ +( +maj +, +m +) \ + +137 (( +__GNUC__ + << 16+ +__GNUC_MINOR__ + >(( +maj +<< 16+ ( +m +)) + + ) + +139  + #__GNUC_PREREQ +( +maj +, +m +0 + + ) + +144 #i +defed + +_BSD_SOURCE + && \ + +145 !( +defed + + g_POSIX_SOURCE + || defed + g_POSIX_C_SOURCE + || \ + +146 +defed + + g_XOPEN_SOURCE + || defed + g_XOPEN_SOURCE_EXTENDED + || \ + +147 +defed + + g_GNU_SOURCE + || defed + g_SVID_SOURCE +) + +148  + #__FAVOR_BSD + 1 + + ) + +152 #ifde +_GNU_SOURCE + + +153 #unde +_ISOC99_SOURCE + + +154  + #_ISOC99_SOURCE + 1 + + ) + +155 #unde +_POSIX_SOURCE + + +156  + #_POSIX_SOURCE + 1 + + ) + +157 #unde +_POSIX_C_SOURCE + + +158  + #_POSIX_C_SOURCE + 200809L + + ) + +159 #unde +_XOPEN_SOURCE + + +160  + #_XOPEN_SOURCE + 700 + + ) + +161 #unde +_XOPEN_SOURCE_EXTENDED + + +162  + #_XOPEN_SOURCE_EXTENDED + 1 + + ) + +163 #unde +_LARGEFILE64_SOURCE + + +164  + #_LARGEFILE64_SOURCE + 1 + + ) + +165 #unde +_BSD_SOURCE + + +166  + #_BSD_SOURCE + 1 + + ) + +167 #unde +_SVID_SOURCE + + +168  + #_SVID_SOURCE + 1 + + ) + +169 #unde +_ATFILE_SOURCE + + +170  + #_ATFILE_SOURCE + 1 + + ) + +175 #i(! +defed + +__STRICT_ANSI__ + && !defed +_ISOC99_SOURCE + && \ + +176 ! +defed + + g_POSIX_SOURCE + && !defed + g_POSIX_C_SOURCE + && \ + +177 ! +defed + + g_XOPEN_SOURCE + && !defed + g_XOPEN_SOURCE_EXTENDED + && \ + +178 ! +defed + + g_BSD_SOURCE + && !defed + g_SVID_SOURCE +) + +179  + #_BSD_SOURCE + 1 + + ) + +180  + #_SVID_SOURCE + 1 + + ) + +187 #i( +defed + +_ISOC99_SOURCE + || defed +_ISOC9X_SOURCE + \ + +188 || ( +defed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L)) + +189  + #__USE_ISOC99 + 1 + + ) + +193 #i( +defed + +_ISOC99_SOURCE + || defed +_ISOC9X_SOURCE + \ + +194 || ( +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199409L)) + +195  + #__USE_ISOC95 + 1 + + ) + +200 #i((! +defed + +__STRICT_ANSI__ + || ( +_XOPEN_SOURCE + - 0) >= 500) && \ + +201 ! +defed + +_POSIX_SOURCE + && !defed +_POSIX_C_SOURCE +) + +202  + #_POSIX_SOURCE + 1 + + ) + +203 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 500 + +204  + #_POSIX_C_SOURCE + 2 + + ) + +205 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 600 + +206  + #_POSIX_C_SOURCE + 199506L + + ) + +207 #i +defed + +_XOPEN_SOURCE + && (_XOPEN_SOURCE - 0) < 700 + +208  + #_POSIX_C_SOURCE + 200112L + + ) + +210  + #_POSIX_C_SOURCE + 200809L + + ) + +212  + #__USE_POSIX_IMPLICITLY + 1 + + ) + +215 #i +defed + +_POSIX_SOURCE + || +_POSIX_C_SOURCE + >1 || defed +_XOPEN_SOURCE + + +216  + #__USE_POSIX + 1 + + ) + +219 #i +defed + +_POSIX_C_SOURCE + && _POSIX_C_SOURCE >2 || defed +_XOPEN_SOURCE + + +220  + #__USE_POSIX2 + 1 + + ) + +223 #i( +_POSIX_C_SOURCE + - 0) >= 199309L + +224  + #__USE_POSIX199309 + 1 + + ) + +227 #i( +_POSIX_C_SOURCE + - 0) >= 199506L + +228  + #__USE_POSIX199506 + 1 + + ) + +231 #i( +_POSIX_C_SOURCE + - 0) >= 200112L + +232  + #__USE_XOPEN2K + 1 + + ) + +233 #unde +__USE_ISOC99 + + +234  + #__USE_ISOC99 + 1 + + ) + +237 #i( +_POSIX_C_SOURCE + - 0) >= 200809L + +238  + #__USE_XOPEN2K8 + 1 + + ) + +239 #unde +_ATFILE_SOURCE + + +240  + #_ATFILE_SOURCE + 1 + + ) + +243 #ifdef +_XOPEN_SOURCE + + +244  + #__USE_XOPEN + 1 + + ) + +245 #i( +_XOPEN_SOURCE + - 0) >= 500 + +246  + #__USE_XOPEN_EXTENDED + 1 + + ) + +247  + #__USE_UNIX98 + 1 + + ) + +248 #unde +_LARGEFILE_SOURCE + + +249  + #_LARGEFILE_SOURCE + 1 + + ) + +250 #i( +_XOPEN_SOURCE + - 0) >= 600 + +251 #i( +_XOPEN_SOURCE + - 0) >= 700 + +252  + #__USE_XOPEN2K8 + 1 + + ) + +254  + #__USE_XOPEN2K + 1 + + ) + +255 #unde +__USE_ISOC99 + + +256  + #__USE_ISOC99 + 1 + + ) + +259 #ifde +_XOPEN_SOURCE_EXTENDED + + +260  + #__USE_XOPEN_EXTENDED + 1 + + ) + +265 #ifde +_LARGEFILE_SOURCE + + +266  + #__USE_LARGEFILE + 1 + + ) + +269 #ifde +_LARGEFILE64_SOURCE + + +270  + #__USE_LARGEFILE64 + 1 + + ) + +273 #i +defed + +_FILE_OFFSET_BITS + && _FILE_OFFSET_BITS == 64 + +274  + #__USE_FILE_OFFSET64 + 1 + + ) + +277 #i +defed + +_BSD_SOURCE + || defed +_SVID_SOURCE + + +278  + #__USE_MISC + 1 + + ) + +281 #ifdef +_BSD_SOURCE + + +282  + #__USE_BSD + 1 + + ) + +285 #ifdef +_SVID_SOURCE + + +286  + #__USE_SVID + 1 + + ) + +289 #ifdef +_ATFILE_SOURCE + + +290  + #__USE_ATFILE + 1 + + ) + +293 #ifdef +_GNU_SOURCE + + +294  + #__USE_GNU + 1 + + ) + +297 #i +defed + +_REENTRANT + || defed +_THREAD_SAFE + + +298  + #__USE_REENTRANT + 1 + + ) + +301 #i +defed + +_FORTIFY_SOURCE + && _FORTIFY_SOURCE > 0 \ + +302 && +__GNUC_PREREQ + (4, 1&& +defed + + g__OPTIMIZE__ + && __OPTIMIZE__ > 0 + +303 #i +_FORTIFY_SOURCE + > 1 + +304  + #__USE_FORTIFY_LEVEL + 2 + + ) + +306  + #__USE_FORTIFY_LEVEL + 1 + + ) + +309  + #__USE_FORTIFY_LEVEL + 0 + + ) + +313  + ~ + +316  + #__STDC_ISO_10646__ + 200009L + + ) + +324 #unde +__GNU_LIBRARY__ + + +325  + #__GNU_LIBRARY__ + 6 + + ) + +329  + #__GLIBC__ + 2 + + ) + +330  + #__GLIBC_MINOR__ + 11 + + ) + +332  + #__GLIBC_PREREQ +( +maj +, +m +) \ + +333 (( +__GLIBC__ + << 16+ +__GLIBC_MINOR__ + >(( +maj +<< 16+ ( +m +)) + + ) + +336 #i +defed + +__GNUC__ + \ + +337 || ( +defed + + g__PGI + && defed + g__i386__ + ) \ + +338 || ( +defed + + g__INTEL_COMPILER + && (defed + g__i386__ + || defed + g__64__ +)) \ + +339 || ( +defed + + g__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L) + +340  + #__GLIBC_HAVE_LONG_LONG + 1 + + ) + +344 #ide +__ASSEMBLER__ + + +345 #ide +_SYS_CDEFS_H + + +346  + ~ + +351 #i +defed + +__USE_FILE_OFFSET64 + && !defed +__REDIRECT + + +352  + #__USE_LARGEFILE + 1 + + ) + +353  + #__USE_LARGEFILE64 + 1 + + ) + +359 #i +__GNUC_PREREQ + (2, 7&& +defed + +__OPTIMIZE__ + \ + +360 && ! +defed + + g__OPTIMIZE_SIZE__ + && !defed + g__NO_INLINE__ + \ + +361 && +defed + + g__ex_le + + +362  + #__USE_EXTERN_INLINES + 1 + + ) + +367 #i +__GNUC_PREREQ + (2, 7&& +defed + +__OPTIMIZE__ + \ + +368 && ( +defed + + g_LIBC + || !defed + g__OPTIMIZE_SIZE__ +&& !defed + g__NO_INLINE__ + \ + +369 && +defed + + g__ex_le + + +370  + #__USE_EXTERN_INLINES_IN_LIBC + 1 + + ) + +378  + ~ + + @/usr/include/getopt.h + +21 #ide +_GETOPT_H + + +23 #ide +__ed_gt + + +24  + #_GETOPT_H + 1 + + ) + +34 #i! +defed + +__GNU_LIBRARY__ + + +35  + ~ + +38 #ide +__THROW + + +39 #ide +__GNUC_PREREQ + + +40  + #__GNUC_PREREQ +( +maj +, +m +(0) + + ) + +42 #i +defed + +__lulus + && +__GNUC_PREREQ + (2,8) + +43  + #__THROW + + `throw + () + + ) + +45  + #__THROW + + + ) + +49 #ifdef +__lulus + + +59 * +ݏrg +; + +73  +td +; + +78  +݋ +; + +82  +tt +; + +84 #ide +__ed_gt + + +106  + sti + + +108 cڡ * + gme +; + +111  + ghas_g +; + +112 * + gag +; + +113  + gv +; + +118  + #no_gumt + 0 + + ) + +119  + #qued_gumt + 1 + + ) + +120  + #tiڮ_gumt + 2 + + ) + +148 #ifde +__GNU_LIBRARY__ + + +152  +gt + ( +___gc +, *cڡ * +___gv +, cڡ * +__shtts +) + +153 +__THROW +; + +155 #i +defed + +__ed_gt + && defed +__USE_POSIX2 + \ + +156 && ! +defed + + g__USE_POSIX_IMPLICITLY + && !defed + g__USE_GNU + + +160 #ifde +__REDIRECT + + +161  +__REDIRECT + ( +gt +, ( +___gc +, *cڡ * +___gv +, + +162 cڡ * +__shtts +), + +163 +__posix_gt + +__THROW +; + +165  +__posix_gt + ( +___gc +, *cڡ * +___gv +, + +166 cڡ * +__shtts + +__THROW +; + +167  + #gt + +__posix_gt + + + ) + +171  +gt + (); + +174 #ide +__ed_gt + + +175  +gt_lg + ( +___gc +, *cڡ * +___gv +, + +176 cڡ * +__shtts +, + +177 cڡ  +ti + * +__lgts +, * +__lgd +) + +178 +__THROW +; + +179  +gt_lg_ly + ( +___gc +, *cڡ * +___gv +, + +180 cڡ * +__shtts +, + +181 cڡ  +ti + * +__lgts +, * +__lgd +) + +182 +__THROW +; + +186 #ifdef +__lulus + + +191 #unde +__ed_gt + + + @/usr/include/libio.h + +29 #ide +_IO_STDIO_H + + +30  + #_IO_STDIO_H + + + ) + +32  + ~<_G_cfig.h +> + +34  + #_IO_pos_t + +_G_os_t + + + ) + +35  + #_IO_os_t + +_G_os_t + + + ) + +36  + #_IO_os64_t + +_G_os64_t + + + ) + +37  + #_IO_size_t + +_G_size_t + + + ) + +38  + #_IO_ssize_t + +_G_ssize_t + + + ) + +39  + #_IO_off_t + +_G_off_t + + + ) + +40  + #_IO_off64_t + +_G_off64_t + + + ) + +41  + #_IO_pid_t + +_G_pid_t + + + ) + +42  + #_IO_uid_t + +_G_uid_t + + + ) + +43  + #_IO_icv_t + +_G_icv_t + + + ) + +44  + #_IO_HAVE_SYS_WAIT + +_G_HAVE_SYS_WAIT + + + ) + +45  + #_IO_HAVE_ST_BLKSIZE + +_G_HAVE_ST_BLKSIZE + + + ) + +46  + #_IO_BUFSIZ + +_G_BUFSIZ + + + ) + +47  + #_IO_va_li + +_G_va_li + + + ) + +48  + #_IO_wt_t + +_G_wt_t + + + ) + +50 #ifde +_G_NEED_STDARG_H + + +52  + #__ed___va_li + + + ) + +53  + ~ + +54 #ifde +__GNUC_VA_LIST + + +55 #unde +_IO_va_li + + +56  + #_IO_va_li + +__gnuc_va_li + + + ) + +60 #ide +__P + + +61 #i +_G_HAVE_SYS_CDEFS + + +62  + ~ + +64 #ifde +__STDC__ + + +65  + #__P +( +p + + ) +p + +66  + #__PMT +( +p + + ) +p + +68  + #__P +( +p +() + + ) + +69  + #__PMT +( +p +() + + ) + +75 #ide +_PARAMS + + +76  + #_PARAMS +( +os + + `__P +ros) + + ) + +79 #ide +__STDC__ + + +81 cڡ + + ) + +84  + #_IO_UNIFIED_JUMPTABLES + 1 + + ) + +85 #ide +_G_HAVE_PRINTF_FP + + +86  + #_IO_USE_DTOA + 1 + + ) + +89 #ide +EOF + + +90  + #EOF + (-1) + + ) + +92 #ide +NULL + + +93 #i +defed + +__GNUG__ + && \ + +94 ( + g__GNUC__ + > 2 || (__GNUC__ =2 && +__GNUC_MINOR__ + >= 8)) + +95  + #NULL + ( +__nu +) + + ) + +97 #i! +defed +( +__lulus +) + +98  + #NULL + ((*)0) + + ) + +100  + #NULL + (0) + + ) + +105  + #_IOS_INPUT + 1 + + ) + +106  + #_IOS_OUTPUT + 2 + + ) + +107  + #_IOS_ATEND + 4 + + ) + +108  + #_IOS_APPEND + 8 + + ) + +109  + #_IOS_TRUNC + 16 + + ) + +110  + #_IOS_NOCREATE + 32 + + ) + +111  + #_IOS_NOREPLACE + 64 + + ) + +112  + #_IOS_BIN + 128 + + ) + +120  + #_IO_MAGIC + 0xFBAD0000 + + ) + +121  + #_OLD_STDIO_MAGIC + 0xFABC0000 + + ) + +122  + #_IO_MAGIC_MASK + 0xFFFF0000 + + ) + +123  + #_IO_USER_BUF + 1 + + ) + +124  + #_IO_UNBUFFERED + 2 + + ) + +125  + #_IO_NO_READS + 4 + + ) + +126  + #_IO_NO_WRITES + 8 + + ) + +127  + #_IO_EOF_SEEN + 0x10 + + ) + +128  + #_IO_ERR_SEEN + 0x20 + + ) + +129  + #_IO_DELETE_DONT_CLOSE + 0x40 + + ) + +130  + #_IO_LINKED + 0x80 + + ) + +131  + #_IO_IN_BACKUP + 0x100 + + ) + +132  + #_IO_LINE_BUF + 0x200 + + ) + +133  + #_IO_TIED_PUT_GET + 0x400 + + ) + +134  + #_IO_CURRENTLY_PUTTING + 0x800 + + ) + +135  + #_IO_IS_APPENDING + 0x1000 + + ) + +136  + #_IO_IS_FILEBUF + 0x2000 + + ) + +137  + #_IO_BAD_SEEN + 0x4000 + + ) + +138  + #_IO_USER_LOCK + 0x8000 + + ) + +140  + #_IO_FLAGS2_MMAP + 1 + + ) + +141  + #_IO_FLAGS2_NOTCANCEL + 2 + + ) + +142 #ifde +_LIBC + + +143  + #_IO_FLAGS2_FORTIFY + 4 + + ) + +145  + #_IO_FLAGS2_USER_WBUF + 8 + + ) + +146 #ifde +_LIBC + + +147  + #_IO_FLAGS2_SCANF_STD + 16 + + ) + +151  + #_IO_SKIPWS + 01 + + ) + +152  + #_IO_LEFT + 02 + + ) + +153  + #_IO_RIGHT + 04 + + ) + +154  + #_IO_INTERNAL + 010 + + ) + +155  + #_IO_DEC + 020 + + ) + +156  + #_IO_OCT + 040 + + ) + +157  + #_IO_HEX + 0100 + + ) + +158  + #_IO_SHOWBASE + 0200 + + ) + +159  + #_IO_SHOWPOINT + 0400 + + ) + +160  + #_IO_UPPERCASE + 01000 + + ) + +161  + #_IO_SHOWPOS + 02000 + + ) + +162  + #_IO_SCIENTIFIC + 04000 + + ) + +163  + #_IO_FIXED + 010000 + + ) + +164  + #_IO_UNITBUF + 020000 + + ) + +165  + #_IO_STDIO + 040000 + + ) + +166  + #_IO_DONT_CLOSE + 0100000 + + ) + +167  + #_IO_BOOLALPHA + 0200000 + + ) + +170  +_IO_jump_t +;  + g_IO_FILE +; + +173 #ifde +_IO_MTSAFE_IO + + +174 #i +defed + +__GLIBC__ + && __GLIBC__ >= 2 + +175  + ~ + +180  + t_IO_lock_t +; + +186  + s_IO_mk + { + +187  +_IO_mk + * + m_xt +; + +188  +_IO_FILE + * + m_sbuf +; + +192  + m_pos +; + +194  +t_ampos +( +ampos + + +{ + m_os + = sp; } + +195  +t_offt +( +offt +{ + m_pos + = offt; + m_os + = ( +ampos +)(-2); } + +196 + mpublic +: + +197 +ammk +( +ambuf + * +sb +); + +198 ~ +ammk +(); + +199  +vg +({  + m_os + == -2; } + +200  +d +( +ammk +&); + +201  +d +(); + +206 + e__codecvt_su + + +208 + m__codecvt_ok +, + +209 + m__codecvt_l +, + +210 + m__codecvt_r +, + +211 + m__codecvt_nocv + + +214 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +217  + s_IO_codecvt + + +219 (* + m__codecvt_der +( + m_IO_codecvt + *); + +220 +__codecvt_su + (* +__codecvt_do_out +( + m_IO_codecvt + *, + +221 + m__mbe_t + *, + +222 cڡ + mwch_t + *, + +223 cڡ + mwch_t + *, + +224 cڡ + mwch_t + **, *, + +226 +__codecvt_su + (* +__codecvt_do_unshi +( + m_IO_codecvt + *, + +227 + m__mbe_t + *, *, + +229 +__codecvt_su + (* +__codecvt_do_ +( + m_IO_codecvt + *, + +230 + m__mbe_t + *, + +232 cڡ **, + mwch_t + *, + +233 + mwch_t + *, wchar_t **); + +234 (* + m__codecvt_do_codg +( + m_IO_codecvt + *); + +235 (* + m__codecvt_do_ways_nocv +( + m_IO_codecvt + *); + +236 (* + m__codecvt_do_ngth +( + m_IO_codecvt + *, + m__mbe_t + *, + +237 cڡ *, cڡ *, + m_IO_size_t +); + +238 (* + m__codecvt_do_max_ngth +( + m_IO_codecvt + *); + +240 +_IO_icv_t + + m__cd_ +; + +241 +_IO_icv_t + + m__cd_out +; + +245  + s_IO_wide_da + + +247 +wch_t + * + m_IO_ad_r +; + +248 +wch_t + * + m_IO_ad_d +; + +249 +wch_t + * + m_IO_ad_ba +; + +250 +wch_t + * + m_IO_wre_ba +; + +251 +wch_t + * + m_IO_wre_r +; + +252 +wch_t + * + m_IO_wre_d +; + +253 +wch_t + * + m_IO_buf_ba +; + +254 +wch_t + * + m_IO_buf_d +; + +256 +wch_t + * + m_IO_ve_ba +; + +257 +wch_t + * + m_IO_backup_ba +; + +259 +wch_t + * + m_IO_ve_d +; + +261 +__mbe_t + + m_IO_e +; + +262 +__mbe_t + + m_IO_ϡ_e +; + +263  +_IO_codecvt + + m_codecvt +; + +265 +wch_t + + m_shtbuf +[1]; + +267 cڡ  +_IO_jump_t + * + m_wide_vb +; + +271  + s_IO_FILE + { + +272  + m_ags +; + +273  + #_IO_fe_ags + +_ags + + + ) + +277 * + m_IO_ad_r +; + +278 * + m_IO_ad_d +; + +279 * + m_IO_ad_ba +; + +280 * + m_IO_wre_ba +; + +281 * + m_IO_wre_r +; + +282 * + m_IO_wre_d +; + +283 * + m_IO_buf_ba +; + +284 * + m_IO_buf_d +; + +286 * + m_IO_ve_ba +; + +287 * + m_IO_backup_ba +; + +288 * + m_IO_ve_d +; + +290  +_IO_mk + * + m_mks +; + +292  +_IO_FILE + * + m_cha +; + +294  + m_fo +; + +296  + m_blksize +; + +298  + m_ags2 +; + +300 +_IO_off_t + + m_d_offt +; + +302  + #__HAVE_COLUMN + + + ) + +304  + m_cur_cumn +; + +305 sigd  + m_vb_offt +; + +306  + m_shtbuf +[1]; + +310 +_IO_lock_t + * + m_lock +; + +311 #ifde +_IO_USE_OLD_IO_FILE + + +314  + s_IO_FILE_come + + +316  +_IO_FILE + + m_fe +; + +318 #i +defed + +_G_IO_IO_FILE_VERSION + && _G_IO_IO_FILE_VERSION == 0x20001 + +319 +_IO_off64_t + + m_offt +; + +320 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +322  +_IO_codecvt + * + m_codecvt +; + +323  +_IO_wide_da + * + m_wide_da +; + +324  +_IO_FILE + * + m_䓻s_li +; + +325 * + m_䓻s_buf +; + +326 +size_t + + m_䓻s_size +; + +328 * + m__d1 +; + +329 * + m__d2 +; + +330 * + m__d3 +; + +331 * + m__d4 +; + +332 +size_t + + m__d5 +; + +334  + m_mode +; + +336  + m_unud2 +[15 *  (- 4 *  (*-  ( +size_t +)]; + +340 #ide +__lulus + + +341  +_IO_FILE + + t_IO_FILE +; + +344  + g_IO_FILE_us +; + +346  +_IO_FILE_us + +_IO_2_1_d_ +; + +347  +_IO_FILE_us + +_IO_2_1_dout_ +; + +348  +_IO_FILE_us + +_IO_2_1_dr_ +; + +349 #ide +_LIBC + + +350  + #_IO_d + (( +_IO_FILE +*)(& +_IO_2_1_d_ +)) + + ) + +351  + #_IO_dout + (( +_IO_FILE +*)(& +_IO_2_1_dout_ +)) + + ) + +352  + #_IO_dr + (( +_IO_FILE +*)(& +_IO_2_1_dr_ +)) + + ) + +354 +_IO_FILE + * +_IO_d + +ibu_hidd +; + +355 +_IO_FILE + * +_IO_dout + +ibu_hidd +; + +356 +_IO_FILE + * +_IO_dr + +ibu_hidd +; + +364  +__ssize_t + + t__io_ad_ + (* + t__cook +, * + t__buf +, + tsize_t + + t__nbys +); + +372  +__ssize_t + + t__io_wre_ + (* + t__cook +, + t__cڡ + * + t__buf +, + +373 + tsize_t + + t__n +); + +381  + t__io_ek_ + (* + t__cook +, + t_IO_off64_t + * + t__pos +,  + t__w +); + +384  + t__io_o_ + (* + t__cook +); + +387 #ifde +_GNU_SOURCE + + +389  +__io_ad_ + + tcook_ad_funi_t +; + +390  +__io_wre_ + + tcook_wre_funi_t +; + +391  +__io_ek_ + + tcook_ek_funi_t +; + +392  +__io_o_ + + tcook_o_funi_t +; + +397 +__io_ad_ + * + mad +; + +398 +__io_wre_ + * + mwre +; + +399 +__io_ek_ + * + mek +; + +400 +__io_o_ + * + mo +; + +401 } + t_IO_cook_io_funis_t +; + +402  +_IO_cook_io_funis_t + + tcook_io_funis_t +; + +404  + g_IO_cook_fe +; + +407  +_IO_cook_ + ( +_IO_cook_fe + * +__cfe +,  +__ad_wre +, + +408 * +__cook +, +_IO_cook_io_funis_t + +__s +); + +412 #ifde +__lulus + + +416  +__undow + ( +_IO_FILE + *); + +417  +__uow + ( +_IO_FILE + *); + +418  +__ovow + ( +_IO_FILE + *, ); + +419 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +420 +_IO_wt_t + +__wundow + ( +_IO_FILE + *); + +421 +_IO_wt_t + +__wuow + ( +_IO_FILE + *); + +422 +_IO_wt_t + +__wovow + ( +_IO_FILE + *, _IO_wint_t); + +425 #i +__GNUC__ + >= 3 + +426  + #_IO_BE +( +ex +, +s + + `__but_ex + (x),es) + + ) + +428  + #_IO_BE +( +ex +, +s +x) + + ) + +431  + #_IO_gc_uocked +( +_ +) \ + +432 ( + `_IO_BE + (( +_ +)-> +_IO_ad_r + >(_)-> +_IO_ad_d +, 0) \ + +433 ? + `__uow + ( +_ +: *(*(_)-> +_IO_ad_r +++) + + ) + +434  + #_IO_ekc_uocked +( +_ +) \ + +435 ( + `_IO_BE + (( +_ +)-> +_IO_ad_r + >(_)-> +_IO_ad_d +, 0) \ + +436 && + `__undow + ( +_ += +EOF + ? EOF \ + +437 : *(*( +_ +)-> +_IO_ad_r +) + + ) + +438  + #_IO_putc_uocked +( +_ch +, +_ +) \ + +439 ( + `_IO_BE + (( +_ +)-> +_IO_wre_r + >(_)-> +_IO_wre_d +, 0) \ + +440 ? + `__ovow + ( +_ +, (( +_ch +)) \ + +441 : ((*( +_ +)-> +_IO_wre_r +++ = ( +_ch +))) + + ) + +443 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +444  + #_IO_gwc_uocked +( +_ +) \ + +445 ( + `_IO_BE + (( +_ +)-> +_wide_da + = +NULL + \ + +446 || (( +_ +)-> +_wide_da +-> +_IO_ad_r + \ + +447 >( +_ +)-> +_wide_da +-> +_IO_ad_d +), 0) \ + +448 ? + `__wuow + ( +_ +: ( +_IO_wt_t +*(_)-> +_wide_da +-> +_IO_ad_r +++) + + ) + +449  + #_IO_putwc_uocked +( +_wch +, +_ +) \ + +450 ( + `_IO_BE + (( +_ +)-> +_wide_da + = +NULL + \ + +451 || (( +_ +)-> +_wide_da +-> +_IO_wre_r + \ + +452 >( +_ +)-> +_wide_da +-> +_IO_wre_d +), 0) \ + +453 ? + `__wovow + ( +_ +, +_wch +) \ + +454 : ( +_IO_wt_t +(*( +_ +)-> +_wide_da +-> +_IO_wre_r +++ = ( +_wch +))) + + ) + +457  + #_IO_of_uocked +( +__ +(((__)-> +_ags + & +_IO_EOF_SEEN +!0) + + ) + +458  + #_IO__uocked +( +__ +(((__)-> +_ags + & +_IO_ERR_SEEN +!0) + + ) + +460  +_IO_gc + ( +_IO_FILE + * +__ +); + +461  +_IO_putc + ( +__c +, +_IO_FILE + * +__ +); + +462  +_IO_of + ( +_IO_FILE + * +__ + +__THROW +; + +463  +_IO_ + ( +_IO_FILE + * +__ + +__THROW +; + +465  +_IO_ekc_locked + ( +_IO_FILE + * +__ +); + +468  + #_IO_PENDING_OUTPUT_COUNT +( +_ +) \ + +469 (( +_ +)-> +_IO_wre_r + - (_)-> +_IO_wre_ba +) + + ) + +471  +_IO_ockfe + ( +_IO_FILE + * +__THROW +; + +472  +_IO_fuockfe + ( +_IO_FILE + * +__THROW +; + +473  +_IO_rylockfe + ( +_IO_FILE + * +__THROW +; + +475 #ifde +_IO_MTSAFE_IO + + +476  + #_IO_ekc +( +_ + + `_IO_ekc_locked + (_) + + ) + +477  + #_IO_ockfe +( +_ +) \ + +478 i((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0 + `_IO_ockfe + (_) + + ) + +479  + #_IO_fuockfe +( +_ +) \ + +480 i((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0 + `_IO_fuockfe + (_) + + ) + +482  + #_IO_ekc +( +_ + + `_IO_ekc_uocked + (_) + + ) + +483  + #_IO_ockfe +( +_ + + + ) + +484  + #_IO_fuockfe +( +_ + + + ) + +485  + #_IO_rylockfe +( +_ + + + ) + +486  + #_IO_nup_gi_t +( +_f +, +_ + + + ) + +487  + #_IO_nup_gi_d +( +_Do + + + ) + +490  +_IO_vfsnf + ( +_IO_FILE + * +__ri +, const * __restrict, + +491 +_IO_va_li +, * +__ri +); + +492  +_IO_vrtf + ( +_IO_FILE + * +__ri +, const *__restrict, + +493 +_IO_va_li +); + +494 +_IO_ssize_t + +_IO_dn + ( +_IO_FILE + *, , _IO_ssize_t); + +495 +_IO_size_t + +_IO_sgn + ( +_IO_FILE + *, *, _IO_size_t); + +497 +_IO_off64_t + +_IO_ekoff + ( +_IO_FILE + *, _IO_off64_t, , ); + +498 +_IO_off64_t + +_IO_ekpos + ( +_IO_FILE + *, _IO_off64_t, ); + +500  +_IO__backup_ + ( +_IO_FILE + * +__THROW +; + +502 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +503 +_IO_wt_t + +_IO_gwc + ( +_IO_FILE + * +__ +); + +504 +_IO_wt_t + +_IO_putwc + ( +wch_t + +__wc +, +_IO_FILE + * +__ +); + +505  +_IO_fwide + ( +_IO_FILE + * +__ +,  +__mode + +__THROW +; + +506 #i +__GNUC__ + >= 2 + +509 #i +defed + +_LIBC + && defed +SHARED + + +510  + ~ + +511 #i +SHLIB_COMPAT + ( +libc +, +GLIBC_2_0 +, +GLIBC_2_1 +) + +512  + #_IO_fwide_maybe_comtib + \ + +513 ( + `__but_ex + (& +_IO_d_ud + = +NULL +, 0)) + + ) + +514 cڡ  +_IO_d_ud +; + +515 +wk_ex + ( +_IO_d_ud +); + +518 #ide +_IO_fwide_maybe_comtib + + +519  + #_IO_fwide_maybe_comtib + (0) + + ) + +523  + #_IO_fwide +( +__ +, +__mode +) \ + +524 ({  +__su + = ( +__mode +); \ + +525 i( +__su + < 0 && ! +_IO_fwide_maybe_comtib +) \ + +527 i(( +__ +)-> +_mode + == 0) \ + +529 ( +__ +)-> +_mode + = -1; \ + +530 +__su + = ( +__ +)-> +_mode +; \ + +532 i( + `__but_cڡt_p + ( +__mode +) && (__mode) == 0) \ + +533 +__su + = +_IO_fwide_maybe_comtib + ? -1 : ( +__ +)-> +_mode +; \ + +535 +__su + = + `_IO_fwide + ( +__ +, __result); \ + +536 +__su +; }) + + ) + +539  +_IO_vfwsnf + ( +_IO_FILE + * +__ri +, cڡ +wch_t + * __restrict, + +540 +_IO_va_li +, * +__ri +); + +541  +_IO_vfwtf + ( +_IO_FILE + * +__ri +, cڡ +wch_t + *__restrict, + +542 +_IO_va_li +); + +543 +_IO_ssize_t + +_IO_wdn + ( +_IO_FILE + *, +wt_t +, _IO_ssize_t); + +544  +_IO__wbackup_ + ( +_IO_FILE + * +__THROW +; + +547 #ifde +__LDBL_COMPAT + + +548  + ~ + +551 #ifde +__lulus + + + @/usr/include/xlocale.h + +21 #ide +_XLOCALE_H + + +22  + #_XLOCALE_H + 1 + + ) + +28  + s__lo_ru + + +31  +lo_da + * + m__los +[13]; + +34 cڡ * + m__y_b +; + +35 cڡ * + m__y_tow +; + +36 cڡ * + m__y_tou +; + +39 cڡ * + m__mes +[13]; + +40 } * + t__lo_t +; + +43  +__lo_t + + tlo_t +; + + @/usr/include/_G_config.h + +4 #ide +_G_cfig_h + + +5  + #_G_cfig_h + 1 + + ) + +9  + ~ + +10  + #__ed_size_t + + + ) + +11 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +12  + #__ed_wch_t + + + ) + +14  + #__ed_NULL + + + ) + +15  + ~ + +16  + #__ed_mbe_t + + + ) + +17 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +18  + #__ed_wt_t + + + ) + +20  + ~ + +21  + #_G_size_t + +size_t + + + ) + +24 +__off_t + + m__pos +; + +25 +__mbe_t + + m__e +; + +26 } + t_G_os_t +; + +29 +__off64_t + + m__pos +; + +30 +__mbe_t + + m__e +; + +31 } + t_G_os64_t +; + +32  + #_G_ssize_t + +__ssize_t + + + ) + +33  + #_G_off_t + +__off_t + + + ) + +34  + #_G_off64_t + +__off64_t + + + ) + +35  + #_G_pid_t + +__pid_t + + + ) + +36  + #_G_uid_t + +__uid_t + + + ) + +37  + #_G_wch_t + +wch_t + + + ) + +38  + #_G_wt_t + +wt_t + + + ) + +39  + #_G_64 + +64 + + + ) + +40 #i +defed + +_LIBC + || defed +_GLIBCPP_USE_WCHAR_T + + +41  + ~ + +44  +__gcv_fo + + m__cd +; + +47  +__gcv_fo + + m__cd +; + +48  +__gcv__da + + m__da +; + +49 } + m__combed +; + +50 } + t_G_icv_t +; + +53  + t_G_t16_t + + t__ibu__ + (( + t__mode__ + ( + t__HI__ +))); + +54  + t_G_t32_t + + t__ibu__ + (( + t__mode__ + ( + t__SI__ +))); + +55  + t_G_ut16_t + + t__ibu__ + (( + t__mode__ + ( + t__HI__ +))); + +56  + t_G_ut32_t + + t__ibu__ + (( + t__mode__ + ( + t__SI__ +))); + +58  + #_G_HAVE_BOOL + 1 + + ) + +62  + #_G_HAVE_ATEXIT + 1 + + ) + +63  + #_G_HAVE_SYS_CDEFS + 1 + + ) + +64  + #_G_HAVE_SYS_WAIT + 1 + + ) + +65  + #_G_NEED_STDARG_H + 1 + + ) + +66  + #_G_va_li + +__gnuc_va_li + + + ) + +68  + #_G_HAVE_PRINTF_FP + 1 + + ) + +69  + #_G_HAVE_MMAP + 1 + + ) + +70  + #_G_HAVE_MREMAP + 1 + + ) + +71  + #_G_HAVE_LONG_DOUBLE_IO + 1 + + ) + +72  + #_G_HAVE_IO_FILE_OPEN + 1 + + ) + +73  + #_G_HAVE_IO_GETLINE_INFO + 1 + + ) + +75  + #_G_IO_IO_FILE_VERSION + 0x20001 + + ) + +77  + #_G_OPEN64 + +__ݒ64 + + + ) + +78  + #_G_LSEEK64 + +__lek64 + + + ) + +79  + #_G_MMAP64 + +__mm64 + + + ) + +80  + #_G_FSTAT64 +( +fd +, +buf + + `__fx64 + ( +_STAT_VER +, fd, buf) + + ) + +83  + #_G_HAVE_ST_BLKSIZE + + `defed + ( +_STATBUF_ST_BLKSIZE +) + + ) + +85  + #_G_BUFSIZ + 8192 + + ) + +88  + #_G_NAMES_HAVE_UNDERSCORE + 0 + + ) + +89  + #_G_VTABLE_LABEL_HAS_LENGTH + 1 + + ) + +90  + #_G_USING_THUNKS + 1 + + ) + +91  + #_G_VTABLE_LABEL_PREFIX + "__vt_" + + ) + +92  + #_G_VTABLE_LABEL_PREFIX_ID + +__vt_ + + + ) + +95 #i +defed + +__lulus + || defed +__STDC__ + + +96  + #_G_ARGS +( +ARGLIST + + ) +ARGLIST + +98  + #_G_ARGS +( +ARGLIST +() + + ) + + @/usr/include/bits/libio-ldbl.h + +20 #ide +_IO_STDIO_H + + +24 + $__LDBL_REDIR_DECL + ( +_IO_vfsnf +) + +25 + `__LDBL_REDIR_DECL + ( +_IO_vrtf +) + + @/usr/include/bits/predefs.h + +19 #ide +_FEATURES_H + + +23 #ide +_PREDEFS_H + + +24  + #_PREDEFS_H + + + ) + +27  + #__STDC_IEC_559__ + 1 + + ) + +28  + #__STDC_IEC_559_COMPLEX__ + 1 + + ) + + @/usr/include/bits/stdio-lock.h + +20 #ide +_BITS_STDIO_LOCK_H + + +21  + #_BITS_STDIO_LOCK_H + 1 + + ) + +23  + ~ + +24  + ~ + +28  + #_IO_lock_exnsive + 1 + + ) + +30 ru {  + mlock +;  + mt +; * + mowr +; } + t_IO_lock_t +; + +32  + #_IO_lock_liz + { +LLL_LOCK_INITIALIZER +, 0, +NULL + } + + ) + +34  + #_IO_lock_ +( +_me +) \ + +35 (( +_me +( +_IO_lock_t + +_IO_lock_liz + , 0) + + ) + +37  + #_IO_lock_fi +( +_me +) \ + +38 ((0) + + ) + +40  + #_IO_lock_lock +( +_me +) \ + +42 * +__lf + = +THREAD_SELF +; \ + +43 i(( +_me +). +owr + ! +__lf +) \ + +45 + `l_lock + (( +_me +). +lock +, +LLL_PRIVATE +); \ + +46 ( +_me +). +owr + = +__lf +; \ + +48 ++( +_me +). +t +; \ + +49 } 0) + + ) + +51  + #_IO_lock_ylock +( +_me +) \ + +53  +__su + = 0; \ + +54 * +__lf + = +THREAD_SELF +; \ + +55 i(( +_me +). +owr + ! +__lf +) \ + +57 i( + `l_ylock + (( +_me +). +lock +) == 0) \ + +59 ( +_me +). +owr + = +__lf +; \ + +60 ( +_me +). +t + = 1; \ + +63 +__su + = +EBUSY +; \ + +66 ++( +_me +). +t +; \ + +67 +__su +; \ + +68 }) + + ) + +70  + #_IO_lock_uock +( +_me +) \ + +72 i(--( +_me +). +t + == 0) \ + +74 ( +_me +). +owr + = +NULL +; \ + +75 + `l_uock + (( +_me +). +lock +, +LLL_PRIVATE +); \ + +77 } 0) + + ) + +81  + #_IO_nup_gi_t +( +_f +, +_ +) \ + +82 + `__libc_nup_gi_t + ((( +_ +)-> +_ags + & +_IO_USER_LOCK +=0, +_f +, _) + + ) + +83  + #_IO_nup_gi_t_nrg +( +_f +) \ + +84 + `__libc_nup_gi_t + (1, +_f +, +NULL +) + + ) + +85  + #_IO_nup_gi_d +( +_do +) \ + +86 + `__libc_nup_gi_d + ( +_do +) + + ) + +88 #i +defed + +_LIBC + && !defed +NOT_IN_libc + + +90 #ifde +__EXCEPTIONS + + +91  + #_IO_acque_lock +( +_ +) \ + +93 +_IO_FILE + * +_IO_acque_lock_fe + \ + +94 + `__ibu__ +(( + `nup + ( +_IO_acque_lock_f +))) \ + +95 ( +_ +); \ + +96 + `_IO_ockfe + ( +_IO_acque_lock_fe +); + + ) + +97  + #_IO_acque_lock_r_ags2 +( +_ +) \ + +99 +_IO_FILE + * +_IO_acque_lock_fe + \ + +100 + `__ibu__ +(( + `nup + ( +_IO_acque_lock_r_ags2_f +))) \ + +101 ( +_ +); \ + +102 + `_IO_ockfe + ( +_IO_acque_lock_fe +); + + ) + +104  + #_IO_acque_lock +( +_ + +_IO_acque_lock_eds_exis_abd + + + ) + +105  + #_IO_acque_lock_r_ags2 +( +_ + + `_IO_acque_lock + (_) + + ) + +107  + #_IO_a_lock +( +_ +; } 0) + + ) + + @/usr/include/bits/typesizes.h + +20 #ide +_BITS_TYPES_H + + +24 #idef +_BITS_TYPESIZES_H + + +25  + #_BITS_TYPESIZES_H + 1 + + ) + +30  + #__DEV_T_TYPE + +__UQUAD_TYPE + + + ) + +31  + #__UID_T_TYPE + +__U32_TYPE + + + ) + +32  + #__GID_T_TYPE + +__U32_TYPE + + + ) + +33  + #__INO_T_TYPE + +__ULONGWORD_TYPE + + + ) + +34  + #__INO64_T_TYPE + +__UQUAD_TYPE + + + ) + +35  + #__MODE_T_TYPE + +__U32_TYPE + + + ) + +36  + #__NLINK_T_TYPE + +__UWORD_TYPE + + + ) + +37  + #__OFF_T_TYPE + +__SLONGWORD_TYPE + + + ) + +38  + #__OFF64_T_TYPE + +__SQUAD_TYPE + + + ) + +39  + #__PID_T_TYPE + +__S32_TYPE + + + ) + +40  + #__RLIM_T_TYPE + +__ULONGWORD_TYPE + + + ) + +41  + #__RLIM64_T_TYPE + +__UQUAD_TYPE + + + ) + +42  + #__BLKCNT_T_TYPE + +__SLONGWORD_TYPE + + + ) + +43  + #__BLKCNT64_T_TYPE + +__SQUAD_TYPE + + + ) + +44  + #__FSBLKCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +45  + #__FSBLKCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +46  + #__FSFILCNT_T_TYPE + +__ULONGWORD_TYPE + + + ) + +47  + #__FSFILCNT64_T_TYPE + +__UQUAD_TYPE + + + ) + +48  + #__ID_T_TYPE + +__U32_TYPE + + + ) + +49  + #__CLOCK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +50  + #__TIME_T_TYPE + +__SLONGWORD_TYPE + + + ) + +51  + #__USECONDS_T_TYPE + +__U32_TYPE + + + ) + +52  + #__SUSECONDS_T_TYPE + +__SLONGWORD_TYPE + + + ) + +53  + #__DADDR_T_TYPE + +__S32_TYPE + + + ) + +54  + #__SWBLK_T_TYPE + +__SLONGWORD_TYPE + + + ) + +55  + #__KEY_T_TYPE + +__S32_TYPE + + + ) + +56  + #__CLOCKID_T_TYPE + +__S32_TYPE + + + ) + +57  + #__TIMER_T_TYPE + * + + ) + +58  + #__BLKSIZE_T_TYPE + +__SLONGWORD_TYPE + + + ) + +59  + #__FSID_T_TYPE + su {  +__v +[2]; } + + ) + +60  + #__SSIZE_T_TYPE + +__SWORD_TYPE + + + ) + +63  + #__FD_SETSIZE + 1024 + + ) + + @/usr/include/bits/wordsize.h + +3 #i +defed + +__x86_64__ + + +4  + #__WORDSIZE + 64 + + ) + +5  + #__WORDSIZE_COMPAT32 + 1 + + ) + +7  + #__WORDSIZE + 32 + + ) + + @/usr/include/ctype.h + +24 #idef +_CTYPE_H + + +25  + #_CTYPE_H + 1 + + ) + +27  + ~ + +28  + ~ + +30 + g__BEGIN_DECLS + + +32 #ide +_ISb + + +41  + ~ + +42 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +43  + #_ISb +( +b +(1 << (b)) + + ) + +45  + #_ISb +( +b +((b< 8 ? ((1 << (b)<< 8: ((1 << (b)>> 8)) + + ) + +50 + m_ISu + = +_ISb + (0), + +51 + m_ISlow + = +_ISb + (1), + +52 + m_ISpha + = +_ISb + (2), + +53 + m_ISdig + = +_ISb + (3), + +54 + m_ISxdig + = +_ISb + (4), + +55 + m_ISa + = +_ISb + (5), + +56 + m_ISt + = +_ISb + (6), + +57 + m_ISgph + = +_ISb + (7), + +58 + m_ISbnk + = +_ISb + (8), + +59 + m_ISl + = +_ISb + (9), + +60 + m_ISpun + = +_ISb + (10), + +61 + m_ISnum + = +_ISb + (11) + +81 +__cڡ + ** + $__y_b_loc + () + +82 +__THROW + + `__ibu__ + (( +__cڡ +)); + +83 +__cڡ + +__t32_t + ** + $__y_tow_loc + () + +84 +__THROW + + `__ibu__ + (( +__cڡ +)); + +85 +__cڡ + +__t32_t + ** + $__y_tou_loc + () + +86 +__THROW + + `__ibu__ + (( +__cڡ +)); + +88  + #__isy +( +c +, +ty +) \ + +89 ((* + `__y_b_loc + ())[(( +c +)] & ( +ty +) + + ) + +91  + #__iscii +( +c +(((c& ~0x7f=0 + + ) + +92  + #__tscii +( +c +((c& 0x7f + + ) + +94  + #__exy +( +me +  + `me + ( +__THROW + + + ) + +96 +__BEGIN_NAMESPACE_STD + + +102 + `__exy + ( +ium +); + +103 + `__exy + ( +iha +); + +104 + `__exy + ( +isl +); + +105 + `__exy + ( +isdig +); + +106 + `__exy + ( +iow +); + +107 + `__exy + ( +isgph +); + +108 + `__exy + ( +irt +); + +109 + `__exy + ( +iun +); + +110 + `__exy + ( +isa +); + +111 + `__exy + ( +isu +); + +112 + `__exy + ( +isxdig +); + +116  + $tow + ( +__c + +__THROW +; + +119  + $tou + ( +__c + +__THROW +; + +121 +__END_NAMESPACE_STD + + +125 #ifdef +__USE_ISOC99 + + +126 +__BEGIN_NAMESPACE_C99 + + +128 + `__exy + ( +isbnk +); + +130 +__END_NAMESPACE_C99 + + +133 #ifde +__USE_GNU + + +135  + $isy + ( +__c +,  +__mask + +__THROW +; + +138 #i +defed + +__USE_SVID + || defed +__USE_MISC + || defed +__USE_XOPEN + + +142  + $iscii + ( +__c + +__THROW +; + +146  + $tscii + ( +__c + +__THROW +; + +150 + `__exy + ( +_tou +); + +151 + `__exy + ( +_tow +); + +155  + #__tobody +( +c +, +f +, +a +, +gs +) \ + +156 ( +__exnsi__ + \ + +157 ({  +__s +; \ + +158 i( ( +c +) > 1) \ + +160 i( + `__but_cڡt_p + ( +c +)) \ + +162  +__c + = ( +c +); \ + +163 +__s + = +__c + < -128 || __> 255 ? __: ( +a +)[__c]; \ + +166 +__s + = +f + +gs +; \ + +169 +__s + = ( +a +)[(( +c +)]; \ + +170 +__s +; + } +})) + + ) + +172 #i! +defed + +__NO_CTYPE + && !defed +__lulus + + +173  + #ium +( +c + + `__isy +((c), +_ISnum +) + + ) + +174  + #iha +( +c + + `__isy +((c), +_ISpha +) + + ) + +175  + #isl +( +c + + `__isy +((c), +_ISl +) + + ) + +176  + #isdig +( +c + + `__isy +((c), +_ISdig +) + + ) + +177  + #iow +( +c + + `__isy +((c), +_ISlow +) + + ) + +178  + #isgph +( +c + + `__isy +((c), +_ISgph +) + + ) + +179  + #irt +( +c + + `__isy +((c), +_ISt +) + + ) + +180  + #iun +( +c + + `__isy +((c), +_ISpun +) + + ) + +181  + #isa +( +c + + `__isy +((c), +_ISa +) + + ) + +182  + #isu +( +c + + `__isy +((c), +_ISu +) + + ) + +183  + #isxdig +( +c + + `__isy +((c), +_ISxdig +) + + ) + +185 #ifde +__USE_ISOC99 + + +186  + #isbnk +( +c + + `__isy +((c), +_ISbnk +) + + ) + +189 #ifde +__USE_EXTERN_INLINES + + +190 +__ex_le +  + +191 +__NTH + ( + $tow + ( +__c +)) + +193  +__c + >-128 && __< 256 ? (* + `__y_tow_loc + ())[__c] : __c; + +194 + } +} + +196 +__ex_le +  + +197 +__NTH + ( + $tou + ( +__c +)) + +199  +__c + >-128 && __< 256 ? (* + `__y_tou_loc + ())[__c] : __c; + +200 + } +} + +203 #i +__GNUC__ + >2 && +defed + +__OPTIMIZE__ + && !defed +__lulus + + +204  + #tow +( +c + + `__tobody + (c, +tow +, * + `__y_tow_loc + (), (c)) + + ) + +205  + #tou +( +c + + `__tobody + (c, +tou +, * + `__y_tou_loc + (), (c)) + + ) + +208 #i +defed + +__USE_SVID + || defed +__USE_MISC + || defed +__USE_XOPEN + + +209  + #iscii +( +c + + `__iscii + (c) + + ) + +210  + #tscii +( +c + + `__tscii + (c) + + ) + +212  + #_tow +( +c +(((* + `__y_tow_loc + ())[((c)]) + + ) + +213  + #_tou +( +c +(((* + `__y_tou_loc + ())[((c)]) + + ) + +219 #ifde +__USE_XOPEN2K8 + + +233  + ~ + +237  + #__isy_l +( +c +, +ty +, +lo +) \ + +238 (( +lo +)-> +__y_b +[(( +c +)] & ( +ty +) + + ) + +240  + #__exy_l +( +me +) \ + +241  + `me + (, +__lo_t + +__THROW + + + ) + +247 +__exy_l + ( +ium_l +); + +248 +__exy_l + ( +iha_l +); + +249 +__exy_l + ( +isl_l +); + +250 +__exy_l + ( +isdig_l +); + +251 +__exy_l + ( +iow_l +); + +252 +__exy_l + ( +isgph_l +); + +253 +__exy_l + ( +irt_l +); + +254 +__exy_l + ( +iun_l +); + +255 +__exy_l + ( +isa_l +); + +256 +__exy_l + ( +isu_l +); + +257 +__exy_l + ( +isxdig_l +); + +259 +__exy_l + ( +isbnk_l +); + +263  + $__tow_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +264  + $tow_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +267  + $__tou_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +268  + $tou_l + ( +__c +, +__lo_t + +__l + +__THROW +; + +270 #i +__GNUC__ + >2 && +defed + +__OPTIMIZE__ + && !defed +__lulus + + +271  + #__tow_l +( +c +, +lo +) \ + +272 + `__tobody + ( +c +, +__tow_l +, ( +lo +)-> +__y_tow +, (c,o)) + + ) + +273  + #__tou_l +( +c +, +lo +) \ + +274 + `__tobody + ( +c +, +__tou_l +, ( +lo +)-> +__y_tou +, (c,o)) + + ) + +275  + #tow_l +( +c +, +lo + + `__tow_l + ((c), (lo)) + + ) + +276  + #tou_l +( +c +, +lo + + `__tou_l + ((c), (lo)) + + ) + +280 #ide +__NO_CTYPE + + +281  + #__ium_l +( +c +, +l + + `__isy_l +((c), +_ISnum +, (l)) + + ) + +282  + #__iha_l +( +c +, +l + + `__isy_l +((c), +_ISpha +, (l)) + + ) + +283  + #__isl_l +( +c +, +l + + `__isy_l +((c), +_ISl +, (l)) + + ) + +284  + #__isdig_l +( +c +, +l + + `__isy_l +((c), +_ISdig +, (l)) + + ) + +285  + #__iow_l +( +c +, +l + + `__isy_l +((c), +_ISlow +, (l)) + + ) + +286  + #__isgph_l +( +c +, +l + + `__isy_l +((c), +_ISgph +, (l)) + + ) + +287  + #__irt_l +( +c +, +l + + `__isy_l +((c), +_ISt +, (l)) + + ) + +288  + #__iun_l +( +c +, +l + + `__isy_l +((c), +_ISpun +, (l)) + + ) + +289  + #__isa_l +( +c +, +l + + `__isy_l +((c), +_ISa +, (l)) + + ) + +290  + #__isu_l +( +c +, +l + + `__isy_l +((c), +_ISu +, (l)) + + ) + +291  + #__isxdig_l +( +c +, +l + + `__isy_l +((c), +_ISxdig +, (l)) + + ) + +293  + #__isbnk_l +( +c +, +l + + `__isy_l +((c), +_ISbnk +, (l)) + + ) + +295 #i +defed + +__USE_SVID + || defed +__USE_MISC + + +296  + #__iscii_l +( +c +, +l +(), + `__iscii + (c)) + + ) + +297  + #__tscii_l +( +c +, +l +(), + `__tscii + (c)) + + ) + +300  + #ium_l +( +c +, +l + + `__ium_l + ((c), (l)) + + ) + +301  + #iha_l +( +c +, +l + + `__iha_l + ((c), (l)) + + ) + +302  + #isl_l +( +c +, +l + + `__isl_l + ((c), (l)) + + ) + +303  + #isdig_l +( +c +, +l + + `__isdig_l + ((c), (l)) + + ) + +304  + #iow_l +( +c +, +l + + `__iow_l + ((c), (l)) + + ) + +305  + #isgph_l +( +c +, +l + + `__isgph_l + ((c), (l)) + + ) + +306  + #irt_l +( +c +, +l + + `__irt_l + ((c), (l)) + + ) + +307  + #iun_l +( +c +, +l + + `__iun_l + ((c), (l)) + + ) + +308  + #isa_l +( +c +, +l + + `__isa_l + ((c), (l)) + + ) + +309  + #isu_l +( +c +, +l + + `__isu_l + ((c), (l)) + + ) + +310  + #isxdig_l +( +c +, +l + + `__isxdig_l + ((c), (l)) + + ) + +312  + #isbnk_l +( +c +, +l + + `__isbnk_l + ((c), (l)) + + ) + +314 #i +defed + +__USE_SVID + || defed +__USE_MISC + + +315  + #iscii_l +( +c +, +l + + `__iscii_l + ((c), (l)) + + ) + +316  + #tscii_l +( +c +, +l + + `__tscii_l + ((c), (l)) + + ) + +323 +__END_DECLS + + + @/usr/include/endian.h + +19 #idef +_ENDIAN_H + + +20  + #_ENDIAN_H + 1 + + ) + +22  + ~ + +32  + #__LITTLE_ENDIAN + 1234 + + ) + +33  + #__BIG_ENDIAN + 4321 + + ) + +34  + #__PDP_ENDIAN + 3412 + + ) + +37  + ~ + +41 #ide +__FLOAT_WORD_ORDER + + +42  + #__FLOAT_WORD_ORDER + +__BYTE_ORDER + + + ) + +45 #ifdef +__USE_BSD + + +46  + #LITTLE_ENDIAN + +__LITTLE_ENDIAN + + + ) + +47  + #BIG_ENDIAN + +__BIG_ENDIAN + + + ) + +48  + #PDP_ENDIAN + +__PDP_ENDIAN + + + ) + +49  + #BYTE_ORDER + +__BYTE_ORDER + + + ) + +52 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +53  + #__LONG_LONG_PAIR +( +HI +, +LO +LO, + ) +HI + +54 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +55  + #__LONG_LONG_PAIR +( +HI +, +LO +HI, + ) +LO + +59 #ifde +__USE_BSD + + +61  + ~ + +63 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +64  + #htobe16 +( +x + + `__bsw_16 + (x) + + ) + +65  + #hte16 +( +x +(x) + + ) + +66  + #be16toh +( +x + + `__bsw_16 + (x) + + ) + +67  + #16toh +( +x +(x) + + ) + +69  + #htobe32 +( +x + + `__bsw_32 + (x) + + ) + +70  + #hte32 +( +x +(x) + + ) + +71  + #be32toh +( +x + + `__bsw_32 + (x) + + ) + +72  + #32toh +( +x +(x) + + ) + +74  + #htobe64 +( +x + + `__bsw_64 + (x) + + ) + +75  + #hte64 +( +x +(x) + + ) + +76  + #be64toh +( +x + + `__bsw_64 + (x) + + ) + +77  + #64toh +( +x +(x) + + ) + +79  + #htobe16 +( +x +(x) + + ) + +80  + #hte16 +( +x + + `__bsw_16 + (x) + + ) + +81  + #be16toh +( +x +(x) + + ) + +82  + #16toh +( +x + + `__bsw_16 + (x) + + ) + +84  + #htobe32 +( +x +(x) + + ) + +85  + #hte32 +( +x + + `__bsw_32 + (x) + + ) + +86  + #be32toh +( +x +(x) + + ) + +87  + #32toh +( +x + + `__bsw_32 + (x) + + ) + +89  + #htobe64 +( +x +(x) + + ) + +90  + #hte64 +( +x + + `__bsw_64 + (x) + + ) + +91  + #be64toh +( +x +(x) + + ) + +92  + #64toh +( +x + + `__bsw_64 + (x) + + ) + + @/usr/include/gnu/stubs.h + +4  + ~ + +6 #i +__WORDSIZE + == 32 + +7  + ~ + +8 #i +__WORDSIZE + == 64 + +9  + ~ + + @/usr/include/stdlib.h + +23 #idef +_STDLIB_H + + +25  + ~ + +28  + #__ed_size_t + + + ) + +29 #ide +__ed_mloc_d_oc + + +30  + #__ed_wch_t + + + ) + +31  + #__ed_NULL + + + ) + +33  + ~ + +35 + g__BEGIN_DECLS + + +37 #ide +__ed_mloc_d_oc + + +38  + #_STDLIB_H + 1 + + ) + +40 #i +defed + +__USE_XOPEN + && !defed +_SYS_WAIT_H + + +42  + ~ + +43  + ~ + +45 #ifde +__USE_BSD + + +50 #i +defed + +__GNUC__ + && !defed +__lulus + + +51  + #__WAIT_INT +( +us +) \ + +52 ( + `__exnsi__ + (((uni { + `__tyof +( +us + +__ +;  +__i +; }) \ + +53 { . +__ + = ( +us +}). +__i +)) + + ) + +55  + #__WAIT_INT +( +us +(*(*&(us)) + + ) + +63 #i! +defed + +__GNUC__ + || __GNUC__ < 2 || defed +__lulus + + +64  + #__WAIT_STATUS + * + + ) + +65  + #__WAIT_STATUS_DEFN + * + + ) + +70  +wa + * + m__ur +; + +71 * + m__ +; + +72 } + t__WAIT_STATUS + + t__ibu__ + (( + t__t_uni__ +)); + +73  + #__WAIT_STATUS_DEFN + * + + ) + +78  + #__WAIT_INT +( +us +(us) + + ) + +79  + #__WAIT_STATUS + * + + ) + +80  + #__WAIT_STATUS_DEFN + * + + ) + +85  + #WEXITSTATUS +( +us + + `__WEXITSTATUS + ( + `__WAIT_INT + (us)) + + ) + +86  + #WTERMSIG +( +us + + `__WTERMSIG + ( + `__WAIT_INT + (us)) + + ) + +87  + #WSTOPSIG +( +us + + `__WSTOPSIG + ( + `__WAIT_INT + (us)) + + ) + +88  + #WIFEXITED +( +us + + `__WIFEXITED + ( + `__WAIT_INT + (us)) + + ) + +89  + #WIFSIGNALED +( +us + + `__WIFSIGNALED + ( + `__WAIT_INT + (us)) + + ) + +90  + #WIFSTOPPED +( +us + + `__WIFSTOPPED + ( + `__WAIT_INT + (us)) + + ) + +91 #ifde +__WIFCONTINUED + + +92  + #WIFCONTINUED +( +us + + `__WIFCONTINUED + ( + `__WAIT_INT + (us)) + + ) + +96 +__BEGIN_NAMESPACE_STD + + +100  + mqu +; + +101  + mm +; + +102 } + tdiv_t +; + +105 #ide +__ldiv_t_defed + + +108  + mqu +; + +109  + mm +; + +110 } + tldiv_t +; + +111  + #__ldiv_t_defed + 1 + + ) + +113 + g__END_NAMESPACE_STD + + +115 #i +defed + +__USE_ISOC99 + && !defed +__div_t_defed + + +116 +__BEGIN_NAMESPACE_C99 + + +118 +__exnsi__ + struct + +120  + mqu +; + +121  + mm +; + +122 } + tdiv_t +; + +123  + #__div_t_defed + 1 + + ) + +124 + g__END_NAMESPACE_C99 + + +129  + #RAND_MAX + 2147483647 + + ) + +134  + #EXIT_FAILURE + 1 + + ) + +135  + #EXIT_SUCCESS + 0 + + ) + +139  + #MB_CUR_MAX + ( + `__y_g_mb_cur_max + ()) + + ) + +140 +size_t + + $__y_g_mb_cur_max + ( +__THROW + +__wur +; + +143 +__BEGIN_NAMESPACE_STD + + +145  + $of + ( +__cڡ + * +__Ō +) + +146 +__THROW + +__ibu_pu__ + + `__nnu + ((1) +__wur +; + +148  + $oi + ( +__cڡ + * +__Ō +) + +149 +__THROW + +__ibu_pu__ + + `__nnu + ((1) +__wur +; + +151  + $ + ( +__cڡ + * +__Ō +) + +152 +__THROW + +__ibu_pu__ + + `__nnu + ((1) +__wur +; + +153 +__END_NAMESPACE_STD + + +155 #i +defed + +__USE_ISOC99 + || (defed +__GLIBC_HAVE_LONG_LONG + && defed +__USE_MISC +) + +156 +__BEGIN_NAMESPACE_C99 + + +158 +__exnsi__ +  + $l + ( +__cڡ + * +__Ō +) + +159 +__THROW + +__ibu_pu__ + + `__nnu + ((1) +__wur +; + +160 +__END_NAMESPACE_C99 + + +163 +__BEGIN_NAMESPACE_STD + + +165  + $od + ( +__cڡ + * +__ri + +__Ō +, + +166 ** +__ri + +__dr +) + +167 +__THROW + + `__nnu + ((1) +__wur +; + +168 +__END_NAMESPACE_STD + + +170 #ifdef +__USE_ISOC99 + + +171 +__BEGIN_NAMESPACE_C99 + + +173  + $of + ( +__cڡ + * +__ri + +__Ō +, + +174 ** +__ri + +__dr + +__THROW + + `__nnu + ((1) +__wur +; + +176  + $d + ( +__cڡ + * +__ri + +__Ō +, + +177 ** +__ri + +__dr +) + +178 +__THROW + + `__nnu + ((1) +__wur +; + +179 +__END_NAMESPACE_C99 + + +182 +__BEGIN_NAMESPACE_STD + + +184  + $ + ( +__cڡ + * +__ri + +__Ō +, + +185 ** +__ri + +__dr +,  +__ba +) + +186 +__THROW + + `__nnu + ((1) +__wur +; + +188  + $oul + ( +__cڡ + * +__ri + +__Ō +, + +189 ** +__ri + +__dr +,  +__ba +) + +190 +__THROW + + `__nnu + ((1) +__wur +; + +191 +__END_NAMESPACE_STD + + +193 #i +defed + +__GLIBC_HAVE_LONG_LONG + && defed +__USE_BSD + + +195 +__exnsi__ + + +196  + $oq + ( +__cڡ + * +__ri + +__Ō +, + +197 ** +__ri + +__dr +,  +__ba +) + +198 +__THROW + + `__nnu + ((1) +__wur +; + +200 +__exnsi__ + + +201  + $ouq + ( +__cڡ + * +__ri + +__Ō +, + +202 ** +__ri + +__dr +,  +__ba +) + +203 +__THROW + + `__nnu + ((1) +__wur +; + +206 #i +defed + +__USE_ISOC99 + || (defed +__GLIBC_HAVE_LONG_LONG + && defed +__USE_MISC +) + +207 +__BEGIN_NAMESPACE_C99 + + +209 +__exnsi__ + + +210  + $l + ( +__cڡ + * +__ri + +__Ō +, + +211 ** +__ri + +__dr +,  +__ba +) + +212 +__THROW + + `__nnu + ((1) +__wur +; + +214 +__exnsi__ + + +215  + $ou + ( +__cڡ + * +__ri + +__Ō +, + +216 ** +__ri + +__dr +,  +__ba +) + +217 +__THROW + + `__nnu + ((1) +__wur +; + +218 +__END_NAMESPACE_C99 + + +222 #ifde +__USE_GNU + + +236  + ~ + +240  + $_l + ( +__cڡ + * +__ri + +__Ō +, + +241 ** +__ri + +__dr +,  +__ba +, + +242 +__lo_t + +__loc + +__THROW + + `__nnu + ((1, 4) +__wur +; + +244  + $oul_l + ( +__cڡ + * +__ri + +__Ō +, + +245 ** +__ri + +__dr +, + +246  +__ba +, +__lo_t + +__loc +) + +247 +__THROW + + `__nnu + ((1, 4) +__wur +; + +249 +__exnsi__ + + +250  + $l_l + ( +__cڡ + * +__ri + +__Ō +, + +251 ** +__ri + +__dr +,  +__ba +, + +252 +__lo_t + +__loc +) + +253 +__THROW + + `__nnu + ((1, 4) +__wur +; + +255 +__exnsi__ + + +256  + $ou_l + ( +__cڡ + * +__ri + +__Ō +, + +257 ** +__ri + +__dr +, + +258  +__ba +, +__lo_t + +__loc +) + +259 +__THROW + + `__nnu + ((1, 4) +__wur +; + +261  + $od_l + ( +__cڡ + * +__ri + +__Ō +, + +262 ** +__ri + +__dr +, +__lo_t + +__loc +) + +263 +__THROW + + `__nnu + ((1, 3) +__wur +; + +265  + $of_l + ( +__cڡ + * +__ri + +__Ō +, + +266 ** +__ri + +__dr +, +__lo_t + +__loc +) + +267 +__THROW + + `__nnu + ((1, 3) +__wur +; + +269  + $d_l + ( +__cڡ + * +__ri + +__Ō +, + +270 ** +__ri + +__dr +, + +271 +__lo_t + +__loc +) + +272 +__THROW + + `__nnu + ((1, 3) +__wur +; + +276 #ifde +__USE_EXTERN_INLINES + + +277 +__BEGIN_NAMESPACE_STD + + +278 +__ex_le +  + +279 + `__NTH + ( + $of + ( +__cڡ + * +__Ō +)) + +281  + `od + ( +__Ō +, (** +NULL +); + +282 + } +} + +283 +__ex_le +  + +284 +__NTH + ( + $oi + ( +__cڡ + * +__Ō +)) + +286  ( + ` + ( +__Ō +, (** +NULL +, 10); + +287 + } +} + +288 +__ex_le +  + +289 +__NTH + ( + $ + ( +__cڡ + * +__Ō +)) + +291  + ` + ( +__Ō +, (** +NULL +, 10); + +292 + } +} + +293 + g__END_NAMESPACE_STD + + +295 #i +defed + +__USE_MISC + || defed +__USE_ISOC99 + + +296 +__BEGIN_NAMESPACE_C99 + + +297 +__exnsi__ + +__ex_le +  + +298 +__NTH + ( + $l + ( +__cڡ + * +__Ō +)) + +300  + `l + ( +__Ō +, (** +NULL +, 10); + +301 + } +} + +302 + g__END_NAMESPACE_C99 + + +307 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + + +311 * + $l64a + ( +__n + +__THROW + +__wur +; + +314  + $a64l + ( +__cڡ + * +__s +) + +315 +__THROW + +__ibu_pu__ + + `__nnu + ((1) +__wur +; + +319 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + || defed +__USE_BSD + + +320  + ~ + +327  + $ndom + ( +__THROW +; + +330  + $dom + ( +__ed + +__THROW +; + +336 * + $e + ( +__ed +, * +__ebuf +, + +337 +size_t + +__ + +__THROW + + `__nnu + ((2)); + +341 * + $te + (* +__ebuf + +__THROW + + `__nnu + ((1)); + +344 #ifde +__USE_MISC + + +349  + sndom_da + + +351 +t32_t + * + +; + +352 +t32_t + * + +; + +353 +t32_t + * +e +; + +354  +nd_ty +; + +355  +nd_deg +; + +356  +nd_p +; + +357 +t32_t + * +d_r +; + +360  + $ndom_r + ( +ndom_da + * +__ri + +__buf +, + +361 +t32_t + * +__ri + +__su + +__THROW + + `__nnu + ((1, 2)); + +363  + $dom_r + ( +__ed +,  +ndom_da + * +__buf +) + +364 +__THROW + + `__nnu + ((2)); + +366  + $e_r + ( +__ed +, * +__ri + +__ebuf +, + +367 +size_t + +__ +, + +368  +ndom_da + * +__ri + +__buf +) + +369 +__THROW + + `__nnu + ((2, 4)); + +371  + $te_r + (* +__ri + +__ebuf +, + +372  +ndom_da + * +__ri + +__buf +) + +373 +__THROW + + `__nnu + ((1, 2)); + +378 +__BEGIN_NAMESPACE_STD + + +380  + $nd + ( +__THROW +; + +382  + $d + ( +__ed + +__THROW +; + +383 +__END_NAMESPACE_STD + + +385 #ifde +__USE_POSIX + + +387  + $nd_r + (* +__ed + +__THROW +; + +391 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +395  + $dnd48 + ( +__THROW +; + +396  + $d48 + ( +__xsubi +[3] +__THROW + + `__nnu + ((1)); + +399  + $̪d48 + ( +__THROW +; + +400  + $Īd48 + ( +__xsubi +[3]) + +401 +__THROW + + `__nnu + ((1)); + +404  + $mnd48 + ( +__THROW +; + +405  + $jnd48 + ( +__xsubi +[3]) + +406 +__THROW + + `__nnu + ((1)); + +409  + $d48 + ( +__edv + +__THROW +; + +410 * + $ed48 + ( +__ed16v +[3]) + +411 +__THROW + + `__nnu + ((1)); + +412  + $lcg48 + ( +__m +[7] +__THROW + + `__nnu + ((1)); + +414 #ifde +__USE_MISC + + +418  + sdnd48_da + + +420  +__x +[3]; + +421  +__d_x +[3]; + +422  +__c +; + +423  +__ +; + +424  +__a +; + +428  + $dnd48_r + ( +dnd48_da + * +__ri + +__bufr +, + +429 * +__ri + +__su + +__THROW + + `__nnu + ((1, 2)); + +430  + $d48_r + ( +__xsubi +[3], + +431  +dnd48_da + * +__ri + +__bufr +, + +432 * +__ri + +__su + +__THROW + + `__nnu + ((1, 2)); + +435  + $̪d48_r + ( +dnd48_da + * +__ri + +__bufr +, + +436 * +__ri + +__su +) + +437 +__THROW + + `__nnu + ((1, 2)); + +438  + $Īd48_r + ( +__xsubi +[3], + +439  +dnd48_da + * +__ri + +__bufr +, + +440 * +__ri + +__su +) + +441 +__THROW + + `__nnu + ((1, 2)); + +444  + $mnd48_r + ( +dnd48_da + * +__ri + +__bufr +, + +445 * +__ri + +__su +) + +446 +__THROW + + `__nnu + ((1, 2)); + +447  + $jnd48_r + ( +__xsubi +[3], + +448  +dnd48_da + * +__ri + +__bufr +, + +449 * +__ri + +__su +) + +450 +__THROW + + `__nnu + ((1, 2)); + +453  + $d48_r + ( +__edv +,  +dnd48_da + * +__bufr +) + +454 +__THROW + + `__nnu + ((2)); + +456  + $ed48_r + ( +__ed16v +[3], + +457  +dnd48_da + * +__bufr + +__THROW + + `__nnu + ((1, 2)); + +459  + $lcg48_r + ( +__m +[7], + +460  +dnd48_da + * +__bufr +) + +461 +__THROW + + `__nnu + ((1, 2)); + +467 #ide +__mloc_d_oc_defed + + +468  + #__mloc_d_oc_defed + + + ) + +469 +__BEGIN_NAMESPACE_STD + + +471 * + $mloc + ( +size_t + +__size + +__THROW + +__ibu_mloc__ + +__wur +; + +473 * + $oc + ( +size_t + +__nmemb +, size_ +__size +) + +474 +__THROW + +__ibu_mloc__ + +__wur +; + +475 +__END_NAMESPACE_STD + + +478 #ide +__ed_mloc_d_oc + + +479 +__BEGIN_NAMESPACE_STD + + +485 * + $loc + (* +__r +, +size_t + +__size +) + +486 +__THROW + +__ibu_wn_unud_su__ +; + +488  + $ + (* +__r + +__THROW +; + +489 +__END_NAMESPACE_STD + + +491 #ifdef +__USE_MISC + + +493  + $c + (* +__r + +__THROW +; + +496 #i +defed + +__USE_GNU + || defed +__USE_BSD + || defed +__USE_MISC + + +497  + ~ + +500 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +502 * + $vloc + ( +size_t + +__size + +__THROW + +__ibu_mloc__ + +__wur +; + +505 #ifde +__USE_XOPEN2K + + +507  + $posix_memign + (** +__memr +, +size_t + +__ignmt +, size_ +__size +) + +508 +__THROW + + `__nnu + ((1) +__wur +; + +511 +__BEGIN_NAMESPACE_STD + + +513  + $abt + ( +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +517  + `ex + ((* +__func +() +__THROW + + `__nnu + ((1)); + +519 #ifde +__USE_GNU + + +523 #ifde +__lulus + + +524 "C++"  + `_quick_ex + ((* +__func +) ()) + +525 +__THROW + + `__asm + ("_quick_ex" + `__nnu + ((1)); + +527  + `_quick_ex + ((* +__func +() +__THROW + + `__nnu + ((1)); + +530 +__END_NAMESPACE_STD + + +532 #ifdef +__USE_MISC + + +535  + `_ex + ((* +__func +( +__us +, * +__g +), *__arg) + +536 +__THROW + + `__nnu + ((1)); + +539 +__BEGIN_NAMESPACE_STD + + +543  + $ex + ( +__us + +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +545 #ifde +__USE_GNU + + +551  + $quick_ex + ( +__us + +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +553 +__END_NAMESPACE_STD + + +555 #ifde +__USE_ISOC99 + + +556 +__BEGIN_NAMESPACE_C99 + + +559  + $_Ex + ( +__us + +__THROW + + `__ibu__ + (( +__nܑu__ +)); + +560 +__END_NAMESPACE_C99 + + +564 +__BEGIN_NAMESPACE_STD + + +566 * + $gv + ( +__cڡ + * +__me + +__THROW + + `__nnu + ((1) +__wur +; + +567 +__END_NAMESPACE_STD + + +571 * + $__cu_gv + ( +__cڡ + * +__me +) + +572 +__THROW + + `__nnu + ((1) +__wur +; + +574 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +578  + $punv + (* +__rg + +__THROW + + `__nnu + ((1)); + +581 #i +defed + +__USE_BSD + || defed +__USE_XOPEN2K + + +584  + $nv + ( +__cڡ + * +__me +, __cڡ * +__vue +,  +__a +) + +585 +__THROW + + `__nnu + ((2)); + +588  + $unnv + ( +__cڡ + * +__me + +__THROW +; + +591 #ifdef +__USE_MISC + + +595  + $nv + ( +__THROW +; + +599 #i +defed + +__USE_MISC + || defed +__USE_XOPEN_EXTENDED + + +604 * + $mkmp + (* +__me + +__THROW + + `__nnu + ((1) +__wur +; + +614 #ide +__USE_FILE_OFFSET64 + + +615  + $mkemp + (* +__me + + `__nnu + ((1) +__wur +; + +617 #ifde +__REDIRECT + + +618  + `__REDIRECT + ( +mkemp +, (* +__me +), +mkemp64 +) + +619 + `__nnu + ((1) +__wur +; + +621  + #mkemp + +mkemp64 + + + ) + +624 #ifde +__USE_LARGEFILE64 + + +625  + $mkemp64 + (* +__me + + `__nnu + ((1) +__wur +; + +629 #ifde +__USE_MISC + + +636 #ide +__USE_FILE_OFFSET64 + + +637  + $mkemps + (* +__me +,  +__suffixn + + `__nnu + ((1) +__wur +; + +639 #ifde +__REDIRECT + + +640  + `__REDIRECT + ( +mkemps +, (* +__me +,  +__suffixn +), + +641 +mkemps64 + + `__nnu + ((1) +__wur +; + +643  + #mkemps + +mkemps64 + + + ) + +646 #ifde +__USE_LARGEFILE64 + + +647  + $mkemps64 + (* +__me +,  +__suffixn +) + +648 + `__nnu + ((1) +__wur +; + +652 #i +defed + +__USE_BSD + || defed +__USE_XOPEN2K8 + + +658 * + $mkdmp + (* +__me + +__THROW + + `__nnu + ((1) +__wur +; + +661 #ifde +__USE_GNU + + +668 #ide +__USE_FILE_OFFSET64 + + +669  + $mkoemp + (* +__me +,  +__ags + + `__nnu + ((1) +__wur +; + +671 #ifde +__REDIRECT + + +672  + `__REDIRECT + ( +mkoemp +, (* +__me +,  +__ags +), +mkoemp64 +) + +673 + `__nnu + ((1) +__wur +; + +675  + #mkoemp + +mkoemp64 + + + ) + +678 #ifde +__USE_LARGEFILE64 + + +679  + $mkoemp64 + (* +__me +,  +__ags + + `__nnu + ((1) +__wur +; + +688 #ide +__USE_FILE_OFFSET64 + + +689  + $mkoemps + (* +__me +,  +__suffixn +,  +__ags +) + +690 + `__nnu + ((1) +__wur +; + +692 #ifde +__REDIRECT + + +693  + `__REDIRECT + ( +mkoemps +, (* +__me +,  +__suffixn +, + +694  +__ags +), +mkoemps64 +) + +695 + `__nnu + ((1) +__wur +; + +697  + #mkoemps + +mkoemps64 + + + ) + +700 #ifde +__USE_LARGEFILE64 + + +701  + $mkoemps64 + (* +__me +,  +__suffixn +,  +__ags +) + +702 + `__nnu + ((1) +__wur +; + +707 +__BEGIN_NAMESPACE_STD + + +712  + $syem + ( +__cڡ + * +__commd + +__wur +; + +713 +__END_NAMESPACE_STD + + +716 #ifdef +__USE_GNU + + +719 * + $nilize_fe_me + ( +__cڡ + * +__me +) + +720 +__THROW + + `__nnu + ((1) +__wur +; + +723 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +729 * + $th + ( +__cڡ + * +__ri + +__me +, + +730 * +__ri + +__sved + +__THROW + +__wur +; + +735 #ide +__COMPAR_FN_T + + +736  + #__COMPAR_FN_T + + + ) + +737 (* + t__comr__t +( + t__cڡ + *, __const *); + +739 #ifdef +__USE_GNU + + +740  +__comr__t + + tcomris__t +; + +743 #ifde +__USE_GNU + + +744 (* + t__comr_d__t +( + t__cڡ + *, __const *, *); + +747 +__BEGIN_NAMESPACE_STD + + +750 * + $bch + ( +__cڡ + * +__key +, __cڡ * +__ba +, + +751 +size_t + +__nmemb +, size_ +__size +, +__comr__t + +__comr +) + +752 + `__nnu + ((1, 2, 5) +__wur +; + +756  + $qst + (* +__ba +, +size_t + +__nmemb +, size_ +__size +, + +757 +__comr__t + +__comr + + `__nnu + ((1, 4)); + +758 #ifde +__USE_GNU + + +759  + $qst_r + (* +__ba +, +size_t + +__nmemb +, size_ +__size +, + +760 +__comr_d__t + +__comr +, * +__g +) + +761 + `__nnu + ((1, 4)); + +766  + $abs + ( +__x + +__THROW + + `__ibu__ + (( +__cڡ__ +) +__wur +; + +767  + $bs + ( +__x + +__THROW + + `__ibu__ + (( +__cڡ__ +) +__wur +; + +768 +__END_NAMESPACE_STD + + +770 #ifde +__USE_ISOC99 + + +771 +__exnsi__ +  + $abs + ( +__x +) + +772 +__THROW + + `__ibu__ + (( +__cڡ__ +) +__wur +; + +776 +__BEGIN_NAMESPACE_STD + + +780 +div_t + + $div + ( +__num +,  +__dom +) + +781 +__THROW + + `__ibu__ + (( +__cڡ__ +) +__wur +; + +782 +ldiv_t + + $ldiv + ( +__num +,  +__dom +) + +783 +__THROW + + `__ibu__ + (( +__cڡ__ +) +__wur +; + +784 +__END_NAMESPACE_STD + + +786 #ifde +__USE_ISOC99 + + +787 +__BEGIN_NAMESPACE_C99 + + +788 +__exnsi__ + +div_t + + $div + ( +__num +, + +789  +__dom +) + +790 +__THROW + + `__ibu__ + (( +__cڡ__ +) +__wur +; + +791 +__END_NAMESPACE_C99 + + +795 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + + +802 * + $ecvt + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +803 * +__ri + +__sign + +__THROW + + `__nnu + ((3, 4) +__wur +; + +808 * + $fcvt + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +809 * +__ri + +__sign + +__THROW + + `__nnu + ((3, 4) +__wur +; + +814 * + $gcvt + ( +__vue +,  +__ndig +, * +__buf +) + +815 +__THROW + + `__nnu + ((3) +__wur +; + +818 #ifde +__USE_MISC + + +820 * + $qecvt + ( +__vue +,  +__ndig +, + +821 * +__ri + +__det +, *__ri +__sign +) + +822 +__THROW + + `__nnu + ((3, 4) +__wur +; + +823 * + $qfcvt + ( +__vue +,  +__ndig +, + +824 * +__ri + +__det +, *__ri +__sign +) + +825 +__THROW + + `__nnu + ((3, 4) +__wur +; + +826 * + $qgcvt + ( +__vue +,  +__ndig +, * +__buf +) + +827 +__THROW + + `__nnu + ((3) +__wur +; + +832  + $ecvt_r + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +833 * +__ri + +__sign +, *__ri +__buf +, + +834 +size_t + +__n + +__THROW + + `__nnu + ((3, 4, 5)); + +835  + $fcvt_r + ( +__vue +,  +__ndig +, * +__ri + +__det +, + +836 * +__ri + +__sign +, *__ri +__buf +, + +837 +size_t + +__n + +__THROW + + `__nnu + ((3, 4, 5)); + +839  + $qecvt_r + ( +__vue +,  +__ndig +, + +840 * +__ri + +__det +, *__ri +__sign +, + +841 * +__ri + +__buf +, +size_t + +__n +) + +842 +__THROW + + `__nnu + ((3, 4, 5)); + +843  + $qfcvt_r + ( +__vue +,  +__ndig +, + +844 * +__ri + +__det +, *__ri +__sign +, + +845 * +__ri + +__buf +, +size_t + +__n +) + +846 +__THROW + + `__nnu + ((3, 4, 5)); + +851 +__BEGIN_NAMESPACE_STD + + +854  + $mbn + ( +__cڡ + * +__s +, +size_t + +__n + +__THROW + +__wur +; + +857  + $mbtowc + ( +wch_t + * +__ri + +__pwc +, + +858 +__cڡ + * +__ri + +__s +, +size_t + +__n + +__THROW + +__wur +; + +861  + $womb + (* +__s +, +wch_t + +__wch + +__THROW + +__wur +; + +865 +size_t + + $mbowcs + ( +wch_t + * +__ri + +__pwcs +, + +866 +__cڡ + * +__ri + +__s +, +size_t + +__n + +__THROW +; + +868 +size_t + + $wcombs + (* +__ri + +__s +, + +869 +__cڡ + +wch_t + * +__ri + +__pwcs +, +size_t + +__n +) + +870 +__THROW +; + +871 +__END_NAMESPACE_STD + + +874 #ifde +__USE_SVID + + +879  + $mch + ( +__cڡ + * +__ڣ + +__THROW + + `__nnu + ((1) +__wur +; + +883 #ifde +__USE_XOPEN_EXTENDED + + +890  + $gsubt + (** +__ri + +__tip +, + +891 * +__cڡ + * +__ri + +__toks +, + +892 ** +__ri + +__vu +) + +893 +__THROW + + `__nnu + ((1, 2, 3) +__wur +; + +897 #ifde +__USE_XOPEN + + +899  + $tkey + ( +__cڡ + * +__key + +__THROW + + `__nnu + ((1)); + +905 #ifde +__USE_XOPEN2K + + +907  + $posix_ݒ + ( +__oag + +__wur +; + +910 #ifde +__USE_XOPEN + + +915  + $g + ( +__fd + +__THROW +; + +919  + $uock + ( +__fd + +__THROW +; + +924 * + $ame + ( +__fd + +__THROW + +__wur +; + +927 #ifde +__USE_GNU + + +931  + $ame_r + ( +__fd +, * +__buf +, +size_t + +__bu +) + +932 +__THROW + + `__nnu + ((2)); + +935  + `g + (); + +938 #ifde +__USE_BSD + + +942  + $gldavg + ( +__ldavg +[],  +__m +) + +943 +__THROW + + `__nnu + ((1)); + +948 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +949  + ~ + +951 #ifde +__LDBL_COMPAT + + +952  + ~ + +956 #unde +__ed_mloc_d_oc + + +958 +__END_DECLS + + + @/usr/include/sys/cdefs.h + +20 #idef +_SYS_CDEFS_H + + +21  + #_SYS_CDEFS_H + 1 + + ) + +24 #ide +_FEATURES_H + + +25  + ~ + +31 #i +defed + +__GNUC__ + && !defed +__STDC__ + + +36 #unde +__P + + +37 #unde +__PMT + + +39 #ifde +__GNUC__ + + +46 #i! +defed + +__lulus + && +__GNUC_PREREQ + (3, 3) + +47  + #__THROW + + `__ibu__ + (( +__nhrow__ +)) + + ) + +48  + #__NTH +( +f + + `__ibu__ + (( +__nhrow__ +) + ) +fct + +50 #i +defed + +__lulus + && +__GNUC_PREREQ + (2,8) + +51  + #__THROW + + `throw + () + + ) + +52  + #__NTH +( +f +f + `throw + () + + ) + +54  + #__THROW + + + ) + +55  + #__NTH +( +f + + ) +fct + +61  + #__le + + + ) + +63  + #__THROW + + + ) + +64  + #__NTH +( +f + + ) +fct + +66  + #__cڡ + cڡ + + ) + +67  + #__sigd + sigd + + ) + +68  + #__vީe + vީe + + ) + +74  + #__P +( +gs + + ) +args + +75  + #__PMT +( +gs + + ) +args + +80  + #__CONCAT +( +x +, +y +x ## + ) +y + +81  + #__STRING +( +x +#x + + ) + +84  + #__r_t + * + + ) + +85  + #__lg_doub_t +  + + ) + +89 #ifdef +__lulus + + +90  + #__BEGIN_DECLS + "C" { + + ) + +91  + #__END_DECLS + } + + ) + +93  + #__BEGIN_DECLS + + + ) + +94  + #__END_DECLS + + + ) + +103 #i +defed + +__lulus + && defed +_GLIBCPP_USE_NAMESPACES + + +104  + #__BEGIN_NAMESPACE_STD + +mea + +d + { + + ) + +105  + #__END_NAMESPACE_STD + } + + ) + +106  + #__USING_NAMESPACE_STD +( +me + +usg + +d +::me; + + ) + +107  + #__BEGIN_NAMESPACE_C99 + +mea + +__c99 + { + + ) + +108  + #__END_NAMESPACE_C99 + } + + ) + +109  + #__USING_NAMESPACE_C99 +( +me + +usg + +__c99 +::me; + + ) + +114  + #__BEGIN_NAMESPACE_STD + + + ) + +115  + #__END_NAMESPACE_STD + + + ) + +116  + #__USING_NAMESPACE_STD +( +me +) + + ) + +117  + #__BEGIN_NAMESPACE_C99 + + + ) + +118  + #__END_NAMESPACE_C99 + + + ) + +119  + #__USING_NAMESPACE_C99 +( +me +) + + ) + +124 #ide +__BOUNDED_POINTERS__ + + +125  + #__bounded + + + ) + +126  + #__unbounded + + + ) + +127  + #__rvue + + + ) + +132  + #__bos +( +r + + `__but_obje_size + (r, +__USE_FORTIFY_LEVEL + > 1) + + ) + +133  + #__bos0 +( +r + + `__but_obje_size + (r, 0) + + ) + +135 #i +__GNUC_PREREQ + (4,3) + +136  + #__wnde +( +me +, +msg +) \ + +137  + `me + ( + `__ibu__ +(( + `__wng__ + ( +msg +))) + + ) + +138  + #__wljr +( +msg + + `__ibu__ +(( + `__wng__ + (msg))) + + ) + +139  + #__rde +( +me +, +msg +) \ + +140  + `me + ( + `__ibu__ +(( + `__r__ + ( +msg +))) + + ) + +142  + #__wnde +( +me +, +msg +  + `me + () + + ) + +143  + #__wljr +( +msg +) + + ) + +144  + #__rde +( +me +, +msg +  + `me + () + + ) + +148 #i +__GNUC_PREREQ + (2,97) + +150  + #__exr + [] + + ) + +152 #ifde +__GNUC__ + + +153  + #__exr + [0] + + ) + +155 #i +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +156  + #__exr + [] + + ) + +159  + #__exr + [1] + + ) + +175 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +177  + #__REDIRECT +( +me +, +o +, +s +m + `__asm__ + ( + `__ASMNAME + (#s)) + + ) + +178 #ifde +__lulus + + +179  + #__REDIRECT_NTH +( +me +, +o +, +s +) \ + +180 +me + +o + +__THROW + + `__asm__ + ( + `__ASMNAME + (#s)) + + ) + +182  + #__REDIRECT_NTH +( +me +, +o +, +s +) \ + +183 +me + +o + + `__asm__ + ( + `__ASMNAME + (#s) +__THROW + + + ) + +185  + #__ASMNAME +( +ame + + `__ASMNAME2 + ( +__USER_LABEL_PREFIX__ +, cme) + + ) + +186  + #__ASMNAME2 +( +efix +, +ame + + `__STRING + (efix + ) +cname + +199 #i! +defed + +__GNUC__ + || __GNUC__ < 2 + +200  + #__ibu__ +( +xyz + + + ) + +206 #i +__GNUC_PREREQ + (2,96) + +207  + #__ibu_mloc__ + + `__ibu__ + (( +__mloc__ +)) + + ) + +209  + #__ibu_mloc__ + + + ) + +215 #i +__GNUC_PREREQ + (2,96) + +216  + #__ibu_pu__ + + `__ibu__ + (( +__pu__ +)) + + ) + +218  + #__ibu_pu__ + + + ) + +224 #i +__GNUC_PREREQ + (3,1) + +225  + #__ibu_ud__ + + `__ibu__ + (( +__ud__ +)) + + ) + +226  + #__ibu_nole__ + + `__ibu__ + (( +__nole__ +)) + + ) + +228  + #__ibu_ud__ + + `__ibu__ + (( +__unud__ +)) + + ) + +229  + #__ibu_nole__ + + + ) + +233 #i +__GNUC_PREREQ + (3,2) + +234  + #__ibu_dd__ + + `__ibu__ + (( +__dd__ +)) + + ) + +236  + #__ibu_dd__ + + + ) + +245 #i +__GNUC_PREREQ + (2,8) + +246  + #__ibu_fm_g__ +( +x + + `__ibu__ + (( + `__fm_g__ + (x))) + + ) + +248  + #__ibu_fm_g__ +( +x + + + ) + +255 #i +__GNUC_PREREQ + (2,97) + +256  + #__ibu_fm_rfm__ +( +a +, +b +) \ + +257 + `__ibu__ + (( + `__fm__ + ( +__rfm__ +, +a +, +b +))) + + ) + +259  + #__ibu_fm_rfm__ +( +a +, +b + + + ) + +264 #i +__GNUC_PREREQ + (3,3) + +265  + #__nnu +( +ms + + `__ibu__ + (( +__nnu__ +ams)) + + ) + +267  + #__nnu +( +ms +) + + ) + +272 #i +__GNUC_PREREQ + (3,4) + +273  + #__ibu_wn_unud_su__ + \ + +274 + `__ibu__ + (( +__wn_unud_su__ +)) + + ) + +275 #i +__USE_FORTIFY_LEVEL + > 0 + +276  + #__wur + +__ibu_wn_unud_su__ + + + ) + +279  + #__ibu_wn_unud_su__ + + + ) + +281 #ide +__wur + + +282  + #__wur + + + ) + +286 #i +__GNUC_PREREQ + (3,2) + +287  + #__ways_le + +__le + + `__ibu__ + (( +__ways_le__ +)) + + ) + +289  + #__ways_le + +__le + + + ) + +294 #i! +defed + +__lulus + || +__GNUC_PREREQ + (4,3) + +295 #i +defed + +__GNUC_STDC_INLINE__ + || defed +__lulus + + +296  + #__ex_le + +__le + + `__ibu__ + (( +__gnu_le__ +)) + + ) + +297 #i +__GNUC_PREREQ + (4,3) + +298  + #__ex_ways_le + \ + +299 +__ways_le + + `__ibu__ + (( +__gnu_le__ +, +__tificl__ +)) + + ) + +301  + #__ex_ways_le + \ + +302 +__ways_le + + `__ibu__ + (( +__gnu_le__ +)) + + ) + +305  + #__ex_le + +__le + + + ) + +306 #i +__GNUC_PREREQ + (4,3) + +307  + #__ex_ways_le + \ + +308 +__ways_le + + `__ibu__ + (( +__tificl__ +)) + + ) + +310  + #__ex_ways_le + +__ways_le + + + ) + +317 #i +__GNUC_PREREQ + (4,3) + +318  + #__va_g_ck +( + `__but_va_g_ck + () + + ) + +319  + #__va_g_ck_n +( + `__but_va_g_ck_n + () + + ) + +326 #i! +__GNUC_PREREQ + (2,8) + +327  + #__exnsi__ + + + ) + +331 #i! +__GNUC_PREREQ + (2,92) + +332  + #__ri + + + ) + +338 #i +__GNUC_PREREQ + (3,1&& ! +defed + +__GNUG__ + + +339  + #__ri_r + +__ri + + + ) + +341 #ifde +__GNUC__ + + +342  + #__ri_r + + + ) + +344 #i +defed + +__STDC_VERSION__ + && __STDC_VERSION__ >= 199901L + +345  + #__ri_r + +ri + + + ) + +348  + #__ri_r + + + ) + +353  + ~ + +355 #i +defed + +__LONG_DOUBLE_MATH_OPTIONAL + && defed +__NO_LONG_DOUBLE_MATH + + +356  + #__LDBL_COMPAT + 1 + + ) + +357 #ifde +__REDIRECT + + +358  + #__LDBL_REDIR1 +( +me +, +o +, +s + + `__REDIRECT + (me,ro,ls) + + ) + +359  + #__LDBL_REDIR +( +me +, +o +) \ + +360 + `__LDBL_REDIR1 + ( +me +, +o +, +__dbl_ +##me) + + ) + +361  + #__LDBL_REDIR1_NTH +( +me +, +o +, +s + + `__REDIRECT_NTH + (me,ro,ls) + + ) + +362  + #__LDBL_REDIR_NTH +( +me +, +o +) \ + +363 + `__LDBL_REDIR1_NTH + ( +me +, +o +, +__dbl_ +##me) + + ) + +364  + #__LDBL_REDIR1_DECL +( +me +, +s +) \ + +365 + `__tyof + ( +me +m + `__asm + ( + `__ASMNAME + (#s)); + + ) + +366  + #__LDBL_REDIR_DECL +( +me +) \ + +367 + `__tyof + ( +me +m + `__asm + ( + `__ASMNAME + ("__dbl_" #me)); + + ) + +368  + #__REDIRECT_LDBL +( +me +, +o +, +s +) \ + +369 + `__LDBL_REDIR1 + ( +me +, +o +, +__dbl_ +## +s +) + + ) + +370  + #__REDIRECT_NTH_LDBL +( +me +, +o +, +s +) \ + +371 + `__LDBL_REDIR1_NTH + ( +me +, +o +, +__dbl_ +## +s +) + + ) + +374 #i! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT + + +375  + #__LDBL_REDIR1 +( +me +, +o +, +s +m + ) +proto + +376  + #__LDBL_REDIR +( +me +, +o +m + ) +proto + +377  + #__LDBL_REDIR1_NTH +( +me +, +o +, +s +m +__THROW + + + ) + +378  + #__LDBL_REDIR_NTH +( +me +, +o +m +__THROW + + + ) + +379  + #__LDBL_REDIR_DECL +( +me +) + + ) + +380 #ifde +__REDIRECT + + +381  + #__REDIRECT_LDBL +( +me +, +o +, +s + + `__REDIRECT + (me,ro,ls) + + ) + +382  + #__REDIRECT_NTH_LDBL +( +me +, +o +, +s +) \ + +383 + `__REDIRECT_NTH + ( +me +, +o +, +s +) + + ) + + @/usr/include/alloca.h + +19 #idef +_ALLOCA_H + + +20  + #_ALLOCA_H + 1 + + ) + +22  + ~ + +24  + #__ed_size_t + + + ) + +25  + ~ + +27 + g__BEGIN_DECLS + + +30 #unde +lo + + +33 * + $lo + ( +size_t + +__size + +__THROW +; + +35 #ifdef +__GNUC__ + + +36  + #lo +( +size + + `__but_lo + (size) + + ) + +39 +__END_DECLS + + + @/usr/include/bits/byteswap.h + +21 #i! +defed + +_BYTESWAP_H + && !defed +_NETINET_IN_H + && !defed +_ENDIAN_H + + +25 #ide +_BITS_BYTESWAP_H + + +26  + #_BITS_BYTESWAP_H + 1 + + ) + +28  + ~ + +31  + #__bsw_cڡt_16 +( +x +) \ + +32 (((( +x +>> 8& 0xff| (((x& 0xff<< 8)) + + ) + +34 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +35  + #__bsw_16 +( +x +) \ + +36 ( +__exnsi__ + \ + +37 ({  +__v +, +__x + = ( +x +); \ + +38 i( + `__but_cڡt_p + ( +__x +)) \ + +39 +__v + = + `__bsw_cڡt_16 + ( +__x +); \ + +41 + `__asm__ + ("rorw $8, %w0" \ + +42 : "" ( +__v +) \ + +43 : "0" ( +__x +) \ + +45 +__v +; })) + + ) + +48  + #__bsw_16 +( +x +) \ + +49 ( +__exnsi__ + \ + +50 ({  +__x + = ( +x +); + `__bsw_cڡt_16 + (__x); })) + + ) + +55  + #__bsw_cڡt_32 +( +x +) \ + +56 (((( +x +) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >> 8) | \ + +57 ((( +x +& 0x0000ff00<< 8| (((x& 0x000000ff<< 24)) + + ) + +59 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +60 #i +__WORDSIZE + =64 || ( +defed + +__i486__ + || defed +__ium__ + \ + +61 || +defed + + g__iumo__ + || defed + g__ium4__ + \ + +62 || +defed + + g__k8__ + || defed + g__hl__ + \ + +63 || +defed + + g__k6__ + || defed + g__noca__ + \ + +64 || +defed + + g__ce2__ + || defed + g__geode__ + \ + +65 || +defed + + g__amdm10__ +) + +68  + #__bsw_32 +( +x +) \ + +69 ( +__exnsi__ + \ + +70 ({  +__v +, +__x + = ( +x +); \ + +71 i( + `__but_cڡt_p + ( +__x +)) \ + +72 +__v + = + `__bsw_cڡt_32 + ( +__x +); \ + +74 + `__asm__ + ("bsw %0" : "" ( +__v +: "0" ( +__x +)); \ + +75 +__v +; })) + + ) + +77  + #__bsw_32 +( +x +) \ + +78 ( +__exnsi__ + \ + +79 ({  +__v +, +__x + = ( +x +); \ + +80 i( + `__but_cڡt_p + ( +__x +)) \ + +81 +__v + = + `__bsw_cڡt_32 + ( +__x +); \ + +83 + `__asm__ + ("rorw $8, %w0;" \ + +86 : "" ( +__v +) \ + +87 : "0" ( +__x +) \ + +89 +__v +; })) + + ) + +92  + #__bsw_32 +( +x +) \ + +93 ( +__exnsi__ + \ + +94 ({  +__x + = ( +x +); + `__bsw_cڡt_32 + (__x); })) + + ) + +98 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +100  + #__bsw_cڡt_64 +( +x +) \ + +101 (((( +x +) & 0xff00000000000000ull) >> 56) \ + +102 | ((( +x +) & 0x00ff000000000000ull) >> 40) \ + +103 | ((( +x +) & 0x0000ff0000000000ull) >> 24) \ + +104 | ((( +x +) & 0x000000ff00000000ull) >> 8) \ + +105 | ((( +x +) & 0x00000000ff000000ull) << 8) \ + +106 | ((( +x +) & 0x0000000000ff0000ull) << 24) \ + +107 | ((( +x +) & 0x000000000000ff00ull) << 40) \ + +108 | ((( +x +& 0x00000000000000ffu<< 56)) + + ) + +110 #i +__WORDSIZE + == 64 + +111  + #__bsw_64 +( +x +) \ + +112 ( +__exnsi__ + \ + +113 ({  +__v +, +__x + = ( +x +); \ + +114 i( + `__but_cڡt_p + ( +__x +)) \ + +115 +__v + = + `__bsw_cڡt_64 + ( +__x +); \ + +117 + `__asm__ + ("bsw %q0" : "" ( +__v +: "0" ( +__x +)); \ + +118 +__v +; })) + + ) + +120  + #__bsw_64 +( +x +) \ + +121 ( +__exnsi__ + \ + +122 ({ uni { +__exnsi__ +  +__ +; \ + +123  +__l +[2]; } +__w +, +__r +; \ + +124 i( + `__but_cڡt_p + ( +x +)) \ + +125 +__r +. +__ + = + `__bsw_cڡt_64 + ( +x +); \ + +128 +__w +. +__ + = ( +x +); \ + +129 +__r +. +__l +[0] = + `__bsw_32 + ( +__w +.__l[1]); \ + +130 +__r +. +__l +[1] = + `__bsw_32 + ( +__w +.__l[0]); \ + +132 +__r +. +__ +; })) + + ) + + @/usr/include/bits/endian.h + +3 #ide +_ENDIAN_H + + +7  + #__BYTE_ORDER + +__LITTLE_ENDIAN + + + ) + + @/usr/include/bits/libc-lock.h + +20 #ide +_BITS_LIBC_LOCK_H + + +21  + #_BITS_LIBC_LOCK_H + 1 + + ) + +23  + ~ + +24  + #__ed_NULL + + + ) + +25  + ~ + +34 #ifde +_LIBC + + +35  + ~ + +36  + ~ + +37  + ~ + +38  + ~ + +39  + ~ + +43 #i +defed + +_LIBC + || defed +_IO_MTSAFE_IO + + +44 #i( +defed + +NOT_IN_libc + && !defed +IS_IN_libhad +|| !defed +_LIBC + + +45  +had_mux_t + + t__libc_lock_t +; + +46 ru { +had_mux_t + + mmux +; } + t__libc_lock_cursive_t +; + +48  + t__libc_lock_t +; + +49 ru {  + mlock +;  + mt +; * + mowr +; } + t__libc_lock_cursive_t +; + +51 ru { +had_mux_t + + mmux +; } + t__ld_lock_cursive_t +; + +52 #ifde +__USE_UNIX98 + + +53  +had_rwlock_t + + t__libc_rwlock_t +; + +55  +__libc_rwlock_aque__ + + t__libc_rwlock_t +; + +58  +__libc_lock_aque__ + + t__libc_lock_t +; + +59  +__libc_lock_cursive_aque__ + + t__libc_lock_cursive_t +; + +60  +__libc_rwlock_aque__ + + t__libc_rwlock_t +; + +64  +had_key_t + + t__libc_key_t +; + +73  + #__libc_lock_defe +( +CLASS +, +NAME +) \ + +74 +CLASS + +__libc_lock_t + +NAME +; + + ) + +75  + #__libc_rwlock_defe +( +CLASS +, +NAME +) \ + +76 +CLASS + +__libc_rwlock_t + +NAME +; + + ) + +77  + #__libc_lock_defe_cursive +( +CLASS +, +NAME +) \ + +78 +CLASS + +__libc_lock_cursive_t + +NAME +; + + ) + +79  + #__ld_lock_defe_cursive +( +CLASS +, +NAME +) \ + +80 +CLASS + +__ld_lock_cursive_t + +NAME +; + + ) + +91 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +92 #i +LLL_LOCK_INITIALIZER + == 0 + +93  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +94 +CLASS + +__libc_lock_t + +NAME +; + + ) + +96  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +97 +CLASS + +__libc_lock_t + +NAME + = +LLL_LOCK_INITIALIZER +; + + ) + +100 #i +__LT_SPINLOCK_INIT + == 0 + +101  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +102 +CLASS + +__libc_lock_t + +NAME +; + + ) + +104  + #__libc_lock_defe_lized +( +CLASS +, +NAME +) \ + +105 +CLASS + +__libc_lock_t + +NAME + = +PTHREAD_MUTEX_INITIALIZER +; + + ) + +109  + #__libc_rwlock_defe_lized +( +CLASS +, +NAME +) \ + +110 +CLASS + +__libc_rwlock_t + +NAME + = +PTHREAD_RWLOCK_INITIALIZER +; + + ) + +114 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +115 #i +LLL_LOCK_INITIALIZER + == 0 + +116  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +117 +CLASS + +__libc_lock_cursive_t + +NAME +; + + ) + +119  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +120 +CLASS + +__libc_lock_cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +122  + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +123 { +LLL_LOCK_INITIALIZER +, 0, +NULL + } + + ) + +125  + #__libc_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +126 +CLASS + +__libc_lock_cursive_t + +NAME + = +_LIBC_LOCK_RECURSIVE_INITIALIZER +; + + ) + +127  + #_LIBC_LOCK_RECURSIVE_INITIALIZER + \ + +128 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +131  + #__ld_lock_defe_lized_cursive +( +CLASS +, +NAME +) \ + +132 +CLASS + +__ld_lock_cursive_t + +NAME + = +_RTLD_LOCK_RECURSIVE_INITIALIZER +; + + ) + +133  + #_RTLD_LOCK_RECURSIVE_INITIALIZER + \ + +134 { +PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP +} + + ) + +136  + #__ld_lock_lize +( +NAME +) \ + +137 ((( +NAME +( +__ld_lock_cursive_t + +_RTLD_LOCK_RECURSIVE_INITIALIZER +) + + ) + +144 #ifde +__PIC__ + + +145  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +) \ + +146 ( + `__exnsi__ + ({ + `__tyof + ( +FUNC +* +_ + = (FUNC); \ + +147 +_ + ! +NULL + ? (*_ +ARGS + : +ELSE +; })) + + ) + +149  + #__libc_maybe_ +( +FUNC +, +ARGS +, +ELSE +) \ + +150 ( +FUNC + ! +NULL + ? FUNC +ARGS + : +ELSE +) + + ) + +154 #i +defed + +SHARED + && !defed +NOT_IN_libc + + +155  + #PTFAVAIL +( +NAME + +__libc_had_funis_ + + + ) + +156  + #__libc_f_ +( +FUNC +, +ARGS +, +ELSE +) \ + +157 ( +__libc_had_funis_ + ? + `PTHFCT_CALL + ( +r_ +## +FUNC +, +ARGS +: +ELSE +) + + ) + +158  + #__libc_f__ways +( +FUNC +, +ARGS +) \ + +159 + `PTHFCT_CALL + ( +r_ +## +FUNC +, +ARGS +) + + ) + +161  + #PTFAVAIL +( +NAME +(NAME ! +NULL +) + + ) + +162  + #__libc_f_ +( +FUNC +, +ARGS +, +ELSE +) \ + +163 + `__libc_maybe_ + ( +FUNC +, +ARGS +, +ELSE +) + + ) + +164  + #__libc_f__ways +( +FUNC +, +ARGS +) \ + +165 +FUNC + +ARGS + + + ) + +171 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +172  + #__libc_lock_ +( +NAME +((NAME +LLL_LOCK_INITIALIZER +, 0) + + ) + +174  + #__libc_lock_ +( +NAME +) \ + +175 + `__libc_maybe_ + ( +__had_mux_ +, (&( +NAME +), +NULL +), 0) + + ) + +177 #i +defed + +SHARED + && !defed +NOT_IN_libc + + +180  + #__libc_rwlock_ +( +NAME +) \ + +181 ( + `__but_memt + (&( +NAME +), '\0',  (NAME)), 0) + + ) + +183  + #__libc_rwlock_ +( +NAME +) \ + +184 + `__libc_maybe_ + ( +__had_rwlock_ +, (&( +NAME +), +NULL +), 0) + + ) + +188 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +189  + #__libc_lock__cursive +( +NAME +) \ + +190 (( +NAME +( +__libc_lock_cursive_t + +_LIBC_LOCK_RECURSIVE_INITIALIZER +, 0) + + ) + +192  + #__libc_lock__cursive +( +NAME +) \ + +194 i( +__had_mux_ + ! +NULL +) \ + +196 +had_mux_t + +__ +; \ + +197 + `__had_mux_ + (& +__ +); \ + +198 + `__had_mux_y + (& +__ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +199 + `__had_mux_ + (&( +NAME +). +mux +, & +__ +); \ + +200 + `__had_mux_deroy + (& +__ +); \ + +202 } 0) + + ) + +205  + #__ld_lock__cursive +( +NAME +) \ + +207 i( +__had_mux_ + ! +NULL +) \ + +209 +had_mux_t + +__ +; \ + +210 + `__had_mux_ + (& +__ +); \ + +211 + `__had_mux_y + (& +__ +, +PTHREAD_MUTEX_RECURSIVE_NP +); \ + +212 + `__had_mux_ + (&( +NAME +). +mux +, & +__ +); \ + +213 + `__had_mux_deroy + (& +__ +); \ + +215 } 0) + + ) + +220 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +221  + #__libc_lock_fi +( +NAME +((0) + + ) + +223  + #__libc_lock_fi +( +NAME +) \ + +224 + `__libc_maybe_ + ( +__had_mux_deroy +, (&( +NAME +)), 0) + + ) + +226 #i +defed + +SHARED + && !defed +NOT_IN_libc + + +227  + #__libc_rwlock_fi +( +NAME +((0) + + ) + +229  + #__libc_rwlock_fi +( +NAME +) \ + +230 + `__libc_maybe_ + ( +__had_rwlock_deroy +, (&( +NAME +)), 0) + + ) + +234 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +235  + #__libc_lock_fi_cursive +( +NAME +((0) + + ) + +237  + #__libc_lock_fi_cursive +( +NAME +) \ + +238 + `__libc_maybe_ + ( +__had_mux_deroy +, (&( +NAME +)), 0) + + ) + +242 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +243 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +247  +__libc_lock_lock_ + ( +__libc_lock_t + *); + +248 +libc_hidd_o + ( +__libc_lock_lock_ +); + +250 #i +__OPTION_EGLIBC_BIG_MACROS + + +251  + #__libc_lock_lock +( +NAME +) \ + +252 ({ + `l_lock + ( +NAME +, +LLL_PRIVATE +); 0; }) + + ) + +254  + #__libc_lock_lock +( +NAME +) \ + +255 + `__libc_lock_lock_ + (&( +NAME +)) + + ) + +258  + #__libc_lock_lock +( +NAME +) \ + +259 + `__libc_maybe_ + ( +__had_mux_lock +, (&( +NAME +)), 0) + + ) + +261  + #__libc_rwlock_rdlock +( +NAME +) \ + +262 + `__libc_f_ + ( +__had_rwlock_rdlock +, (&( +NAME +)), 0) + + ) + +263  + #__libc_rwlock_wock +( +NAME +) \ + +264 + `__libc_f_ + ( +__had_rwlock_wock +, (&( +NAME +)), 0) + + ) + +267 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +268 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +272  +__libc_lock_lock_cursive_ + ( +__libc_lock_cursive_t + *); + +273 +libc_hidd_o + ( +__libc_lock_lock_cursive_ +); + +275 #i +__OPTION_EGLIBC_BIG_MACROS + + +276  + #__libc_lock_lock_cursive +( +NAME +) \ + +278 * +lf + = +THREAD_SELF +; \ + +279 i(( +NAME +). +owr + ! +lf +) \ + +281 + `l_lock + (( +NAME +). +lock +, +LLL_PRIVATE +); \ + +282 ( +NAME +). +owr + = +lf +; \ + +284 ++( +NAME +). +t +; \ + +285 } 0) + + ) + +287  + #__libc_lock_lock_cursive +( +NAME +) \ + +288 + `__libc_lock_lock_cursive_ + (&( +NAME +)) + + ) + +291  + #__libc_lock_lock_cursive +( +NAME +) \ + +292 + `__libc_maybe_ + ( +__had_mux_lock +, (&( +NAME +). +mux +), 0) + + ) + +296 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +297 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +301  +__libc_lock_ylock_ + ( +__libc_lock_t + *); + +302 +libc_hidd_o + ( +__libc_lock_ylock_ +); + +304 #i +__OPTION_EGLIBC_BIG_MACROS + + +305  + #__libc_lock_ylock +( +NAME +) \ + +306 + `l_ylock + ( +NAME +) + + ) + +308  + #__libc_lock_ylock +( +NAME +) \ + +309 + `__libc_lock_ylock_ + (&( +NAME +)) + + ) + +312  + #__libc_lock_ylock +( +NAME +) \ + +313 + `__libc_maybe_ + ( +__had_mux_ylock +, (&( +NAME +)), 0) + + ) + +315  + #__libc_rwlock_yrdlock +( +NAME +) \ + +316 + `__libc_maybe_ + ( +__had_rwlock_yrdlock +, (&( +NAME +)), 0) + + ) + +317  + #__libc_rwlock_ywock +( +NAME +) \ + +318 + `__libc_maybe_ + ( +__had_rwlock_ywock +, (&( +NAME +)), 0) + + ) + +321 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +322 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +326  +__libc_lock_ylock_cursive_ + ( +__libc_lock_cursive_t + *); + +327 +libc_hidd_o + ( +__libc_lock_ylock_cursive_ +); + +329 #i +__OPTION_EGLIBC_BIG_MACROS + + +330  + #__libc_lock_ylock_cursive +( +NAME +) \ + +332  +su + = 0; \ + +333 * +lf + = +THREAD_SELF +; \ + +334 i(( +NAME +). +owr + ! +lf +) \ + +336 i( + `l_ylock + (( +NAME +). +lock +) == 0) \ + +338 ( +NAME +). +owr + = +lf +; \ + +339 ( +NAME +). +t + = 1; \ + +342 +su + = +EBUSY +; \ + +345 ++( +NAME +). +t +; \ + +346 +su +; \ + +347 }) + + ) + +349  + #__libc_lock_ylock_cursive +( +NAME +) \ + +350 + `__libc_lock_ylock_cursive_ + (&( +NAME +)) + + ) + +353  + #__libc_lock_ylock_cursive +( +NAME +) \ + +354 + `__libc_maybe_ + ( +__had_mux_ylock +, (&( +NAME +)), 0) + + ) + +357  + #__ld_lock_ylock_cursive +( +NAME +) \ + +358 + `__libc_maybe_ + ( +__had_mux_ylock +, (&( +NAME +). +mux +), 0) + + ) + +361 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +362 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +366  +__libc_lock_uock_ + ( +__libc_lock_t + *); + +367 +libc_hidd_o + ( +__libc_lock_uock_ +); + +369 #i +__OPTION_EGLIBC_BIG_MACROS + + +370  + #__libc_lock_uock +( +NAME +) \ + +371 + `l_uock + ( +NAME +, +LLL_PRIVATE +) + + ) + +373  + #__libc_lock_uock +( +NAME +) \ + +374 + `__libc_lock_uock_ + (&( +NAME +)) + + ) + +377  + #__libc_lock_uock +( +NAME +) \ + +378 + `__libc_maybe_ + ( +__had_mux_uock +, (&( +NAME +)), 0) + + ) + +380  + #__libc_rwlock_uock +( +NAME +) \ + +381 + `__libc_f_ + ( +__had_rwlock_uock +, (&( +NAME +)), 0) + + ) + +384 #i +defed + +_LIBC + && (!defed +NOT_IN_libc + || defed +IS_IN_libhad +) + +385 #i +__OPTION_EGLIBC_BIG_MACROS + != 1 + +389  +__libc_lock_uock_cursive_ + ( +__libc_lock_cursive_t + *); + +390 +libc_hidd_o + ( +__libc_lock_uock_cursive_ +); + +392 #i +__OPTION_EGLIBC_BIG_MACROS + + +394  + #__libc_lock_uock_cursive +( +NAME +) \ + +396 i(--( +NAME +). +t + == 0) \ + +398 ( +NAME +). +owr + = +NULL +; \ + +399 + `l_uock + (( +NAME +). +lock +, +LLL_PRIVATE +); \ + +401 } 0) + + ) + +403  + #__libc_lock_uock_cursive +( +NAME +) \ + +404 + `__libc_lock_uock_cursive_ + (&( +NAME +)) + + ) + +407  + #__libc_lock_uock_cursive +( +NAME +) \ + +408 + `__libc_maybe_ + ( +__had_mux_uock +, (&( +NAME +)), 0) + + ) + +411 #i +defed + +_LIBC + && defed +SHARED + + +412  + #__ld_lock_deu_lock_cursive +( +lock +) \ + +413 ++(( +had_mux_t + *)( +lock +))-> +__da +. +__cou +; + + ) + +415  + #__ld_lock_deu_uock_cursive +( +lock +) \ + +416 --(( +had_mux_t + *)( +lock +))-> +__da +. +__cou +; + + ) + +418  + #__ld_lock_lock_cursive +( +NAME +) \ + +419 + `GL +( +dl_ld_lock_cursive +(&( +NAME +). +mux +) + + ) + +421  + #__ld_lock_uock_cursive +( +NAME +) \ + +422 + `GL +( +dl_ld_uock_cursive +(&( +NAME +). +mux +) + + ) + +424  + #__ld_lock_lock_cursive +( +NAME +) \ + +425 + `__libc_maybe_ + ( +__had_mux_lock +, (&( +NAME +). +mux +), 0) + + ) + +427  + #__ld_lock_uock_cursive +( +NAME +) \ + +428 + `__libc_maybe_ + ( +__had_mux_uock +, (&( +NAME +). +mux +), 0) + + ) + +432 #i +PTHREAD_ONCE_INIT + == 0 + +435  + #__libc__defe +( +CLASS +, +NAME +) \ + +436 +CLASS + +had__t + +NAME + + + ) + +438  + #__libc__defe +( +CLASS +, +NAME +) \ + +439 +CLASS + +had__t + +NAME + = +PTHREAD_ONCE_INIT + + + ) + +443  + #__libc_ +( +ONCE_CONTROL +, +INIT_FUNCTION +) \ + +445 i( + `PTFAVAIL + ( +__had_ +)) \ + +446 + `__libc_f__ways + ( +__had_ +, (&( +ONCE_CONTROL +), \ + +447 +INIT_FUNCTION +)); \ + +448 i(( +ONCE_CONTROL += +PTHREAD_ONCE_INIT +) { \ + +449 + `INIT_FUNCTION + (); \ + +450 ( +ONCE_CONTROL +) |= 2; \ + +452 } 0) + + ) + +459  +_had_nup_push + ( +_had_nup_bufr + * +bufr +, + +460 (* +route +(*), * +g +); + +461  + `_had_nup_p + ( +_had_nup_bufr + * +bufr +, + +462  +execu +); + +463  + `_had_nup_push_der + ( +_had_nup_bufr + * +bufr +, + +464 (* +route +(*), * +g +); + +465  + `_had_nup_p_e + ( +_had_nup_bufr + * +bufr +, + +466  +execu +); + +469  + #__libc_nup_gi_t +( +DOIT +, +FCT +, +ARG +) \ + +470 {  +_had_nup_bufr + +_bufr +; \ + +471  +_ava +; \ + +472 i( +DOIT +) { \ + +473 +_ava + = + `PTFAVAIL + ( +_had_nup_push_der +); \ + +474 i( +_ava +) { \ + +475 + `__libc_f__ways + ( +_had_nup_push_der +, (& +_bufr +, +FCT +, \ + +476 +ARG +)); \ + +478 +_bufr +. +__route + = ( +FCT +); \ + +479 +_bufr +. +__g + = ( +ARG +); \ + +482 +_ava + = 0; \ + +483 } + + ) + +486  + #__libc_nup_gi_d +( +DOIT +) \ + +487 i( +_ava +) { \ + +488 + `__libc_f__ways + ( +_had_nup_p_e +, (& +_bufr +, +DOIT +));\ + +489 } i( +DOIT +) \ + +490 +_bufr +. + `__route + (_bufr. +__g +); \ + +491 + } + + ) +} + +494  + #__libc_nup_d +( +DOIT +) \ + +495 i( +_ava +) { \ + +496 + `__libc_f__ways + ( +_had_nup_p_e +, (& +_bufr +, +DOIT +));\ + +497 } i( +DOIT +) \ + +498 +_bufr +. + `__route + (_bufr. +__g +) + + ) + +502 +__ex_le +  + +503 + $__libc_nup_route + ( +__had_nup_ame + * +f +) + +505 i( +f +-> +__do_ +) + +506 +f +-> + `__nl_route + (f-> +__nl_g +); + +507 + } +} + +509  + #__libc_nup_push +( +f +, +g +) \ + +511  +__had_nup_ame + +__ame + \ + +512 + `__ibu__ + (( + `__nup__ + ( +__libc_nup_route +))) \ + +513 { . +__nl_route + = ( +f +), . +__nl_g + = ( +g +), \ + +514 . +__do_ + = 1 }; + + ) + +516  + #__libc_nup_p +( +execu +) \ + +517 +__ame +. +__do_ + = ( +execu +); \ + +518 } 0) + + ) + +522  + #__libc_key_ +( +KEY +, +DESTRUCTOR +) \ + +523 + `__libc_f_ + ( +__had_key_ +, ( +KEY +, +DESTRUCTOR +), 1) + + ) + +526  + #__libc_gecific +( +KEY +) \ + +527 + `__libc_f_ + ( +__had_gecific +, ( +KEY +), +NULL +) + + ) + +530  + #__libc_tecific +( +KEY +, +VALUE +) \ + +531 + `__libc_f_ + ( +__had_tecific +, ( +KEY +, +VALUE +), 0) + + ) + +537  + #__libc_fk +( +PREPARE +, +PARENT +, +CHILD +) \ + +538 + `__gi_fk + ( +PREPARE +, +PARENT +, +CHILD +, +NULL +) + + ) + +539  +__gi_fk + ((* +__e +) (), + +540 (* +__ +) (), + +541 (* +__chd +) (), + +542 * +__dso_hd +); + +547  + `__had_mux_ + ( +had_mux_t + * +__mux +, + +548 +__cڡ + +had_mux_t + * +__mux_ +); + +550  + `__had_mux_deroy + ( +had_mux_t + * +__mux +); + +552  + `__had_mux_ylock + ( +had_mux_t + * +__mux +); + +554  + `__had_mux_lock + ( +had_mux_t + * +__mux +); + +556  + `__had_mux_uock + ( +had_mux_t + * +__mux +); + +558  + `__had_mux_ + ( +had_mux_t + * +__ +); + +560  + `__had_mux_deroy + ( +had_mux_t + * +__ +); + +562  + `__had_mux_y + ( +had_mux_t + * +__ +, + +563  +__kd +); + +565 #ifde +__USE_UNIX98 + + +566  + `__had_rwlock_ + ( +had_rwlock_t + * +__rwlock +, + +567 +__cڡ + +had_rwlock_t + * +__ +); + +569  + `__had_rwlock_deroy + ( +had_rwlock_t + * +__rwlock +); + +571  + `__had_rwlock_rdlock + ( +had_rwlock_t + * +__rwlock +); + +573  + `__had_rwlock_yrdlock + ( +had_rwlock_t + * +__rwlock +); + +575  + `__had_rwlock_wock + ( +had_rwlock_t + * +__rwlock +); + +577  + `__had_rwlock_ywock + ( +had_rwlock_t + * +__rwlock +); + +579  + `__had_rwlock_uock + ( +had_rwlock_t + * +__rwlock +); + +582  + `__had_key_ + ( +had_key_t + * +__key +, + +583 (* +__der_funi +) (*)); + +585  + `__had_tecific + ( +had_key_t + +__key +, + +586 +__cڡ + * +__por +); + +588 * + `__had_gecific + ( +had_key_t + +__key +); + +590  + `__had_ + ( +had__t + * +___cڌ +, + +591 (* +___route +) ()); + +593  + `__had_fk + ((* +__e +) (), + +594 (* +__ +) (), + +595 (* +__chd +) ()); + +601 #ide +__NO_WEAK_PTHREAD_ALIASES + + +602 #ifde +wk_ex + + +603 #i +_LIBC + + +604  + ~ + +606  + #BP_SYM +( +sym + + ) +sym + +608 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ +)) + +609 + `wk_ex + ( + $BP_SYM + ( +__had_mux_deroy +)) + +610 + `wk_ex + ( + $BP_SYM + ( +__had_mux_lock +)) + +611 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ylock +)) + +612 + `wk_ex + ( + $BP_SYM + ( +__had_mux_uock +)) + +613 + `wk_ex + ( + $BP_SYM + ( +__had_mux_ +)) + +614 + `wk_ex + ( + $BP_SYM + ( +__had_mux_deroy +)) + +615 + `wk_ex + ( + $BP_SYM + ( +__had_mux_y +)) + +616 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_ +)) + +617 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_deroy +)) + +618 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_rdlock +)) + +619 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_yrdlock +)) + +620 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_wock +)) + +621 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_ywock +)) + +622 + `wk_ex + ( + $BP_SYM + ( +__had_rwlock_uock +)) + +623 + `wk_ex + ( + $BP_SYM + ( +__had_key_ +)) + +624 + `wk_ex + ( + $BP_SYM + ( +__had_tecific +)) + +625 + `wk_ex + ( + $BP_SYM + ( +__had_gecific +)) + +626 + `wk_ex + ( + $BP_SYM + ( +__had_ +)) + +627 + $wk_ex + ( +__had_lize +) + +628 + $wk_ex + ( +__had_fk +) + +629 + `wk_ex + ( + $BP_SYM + ( +_had_nup_push_der +)) + +630 + `wk_ex + ( + $BP_SYM + ( +_had_nup_p_e +)) + +631 + `wk_ex + ( + $BP_SYM + ( +had_tnle +)) + +633 #agm +wk + +__had_mux_ + + +634 #agm +wk + +__had_mux_deroy + + +635 #agm +wk + +__had_mux_lock + + +636 #agm +wk + +__had_mux_ylock + + +637 #agm +wk + +__had_mux_uock + + +638 #agm +wk + +__had_mux_ + + +639 #agm +wk + +__had_mux_deroy + + +640 #agm +wk + +__had_mux_y + + +641 #agm +wk + +__had_rwlock_deroy + + +642 #agm +wk + +__had_rwlock_rdlock + + +643 #agm +wk + +__had_rwlock_yrdlock + + +644 #agm +wk + +__had_rwlock_wock + + +645 #agm +wk + +__had_rwlock_ywock + + +646 #agm +wk + +__had_rwlock_uock + + +647 #agm +wk + +__had_key_ + + +648 #agm +wk + +__had_tecific + + +649 #agm +wk + +__had_gecific + + +650 #agm +wk + +__had_ + + +651 #agm +wk + +__had_lize + + +652 #agm +wk + +__had_fk + + +653 #agm +wk + +_had_nup_push_der + + +654 #agm +wk + +_had_nup_p_e + + +655 #agm +wk + +had_tnle + + + @/usr/include/bits/stdlib-ldbl.h + +20 #ide +_STDLIB_H + + +24 #ifdef +__USE_ISOC99 + + +25 +__BEGIN_NAMESPACE_C99 + + +26 + $__LDBL_REDIR1_DECL + ( +d +, +od +) + +27 +__END_NAMESPACE_C99 + + +30 #ifde +__USE_GNU + + +31 + $__LDBL_REDIR1_DECL + ( +d_l +, +od_l +) + +34 #i +defed + +__USE_SVID + || defed +__USE_XOPEN_EXTENDED + + +35 #ifde +__USE_MISC + + +36 + $__LDBL_REDIR1_DECL + ( +qecvt +, +ecvt +) + +37 + $__LDBL_REDIR1_DECL + ( +qfcvt +, +fcvt +) + +38 + $__LDBL_REDIR1_DECL + ( +qgcvt +, +gcvt +) + +39 + $__LDBL_REDIR1_DECL + ( +qecvt_r +, +ecvt_r +) + +40 + $__LDBL_REDIR1_DECL + ( +qfcvt_r +, +fcvt_r +) + + @/usr/include/bits/stdlib.h + +20 #ide +_STDLIB_H + + +24 * + $__th_chk + ( +__cڡ + * +__ri + +__me +, + +25 * +__ri + +__sved +, + +26 +size_t + +__svedn + +__THROW + +__wur +; + +27 * + `__REDIRECT_NTH + ( +__th_s +, + +28 ( +__cڡ + * +__ri + +__me +, + +29 * +__ri + +__sved +), +th + +__wur +; + +30 * + `__REDIRECT_NTH + ( +__th_chk_wn +, + +31 ( +__cڡ + * +__ri + +__me +, + +32 * +__ri + +__sved +, + +33 +size_t + +__svedn +), +__th_chk + +__wur + + +34 + `__wljr + ("secondrgument ofealpath must beither NULL ort " + +37 +__ex_ways_le + +__wur + * + +38 + `__NTH + ( + $th + ( +__cڡ + * +__ri + +__me +, *__ri +__sved +)) + +40 i( + `__bos + ( +__sved +!( +size_t +) -1) + +42 #i +defed + +_LIBC_LIMITS_H_ + && defed +PATH_MAX + + +43 i( + `__bos + ( +__sved +< +PATH_MAX +) + +44  + `__th_chk_wn + ( +__me +, +__sved +, + `__bos + (__resolved)); + +46  + `__th_chk + ( +__me +, +__sved +, + `__bos + (__resolved)); + +49  + `__th_s + ( +__me +, +__sved +); + +50 + } +} + +53  + $__ame_r_chk + ( +__fd +, * +__buf +, +size_t + +__bu +, + +54 +size_t + +__ėl + +__THROW + + `__nnu + ((2)); + +55  + `__REDIRECT_NTH + ( +__ame_r_s +, ( +__fd +, * +__buf +, + +56 +size_t + +__bu +), +ame_r +) + +57 + `__nnu + ((2)); + +58  + `__REDIRECT_NTH + ( +__ame_r_chk_wn +, + +59 ( +__fd +, * +__buf +, +size_t + +__bu +, + +60 +size_t + +__ėl +), +__ame_r_chk +) + +61 + `__nnu + ((2) + `__wljr + ("ptsname_r called with buflen biggerhan " + +64 +__ex_ways_le +  + +65 + `__NTH + ( + $ame_r + ( +__fd +, * +__buf +, +size_t + +__bu +)) + +67 i( + `__bos + ( +__buf +!( +size_t +) -1) + +69 i(! + `__but_cڡt_p + ( +__bu +)) + +70  + `__ame_r_chk + ( +__fd +, +__buf +, +__bu +, + `__bos + (__buf)); + +71 i( +__bu + > + `__bos + ( +__buf +)) + +72  + `__ame_r_chk_wn + ( +__fd +, +__buf +, +__bu +, + `__bos + (__buf)); + +74  + `__ame_r_s + ( +__fd +, +__buf +, +__bu +); + +75 + } +} + +78  + $__womb_chk + (* +__s +, +wch_t + +__wch +, +size_t + +__bu +) + +79 +__THROW + +__wur +; + +80  + `__REDIRECT_NTH + ( +__womb_s +, (* +__s +, +wch_t + +__wch +), + +81 +womb + +__wur +; + +83 +__ex_ways_le + +__wur +  + +84 + `__NTH + ( + $womb + (* +__s +, +wch_t + +__wch +)) + +89  + #__STDLIB_MB_LEN_MAX + 16 + + ) + +90 #i +defed + +MB_LEN_MAX + && MB_LEN_MAX ! +__STDLIB_MB_LEN_MAX + + +93 i( + `__bos + ( +__s +!( +size_t +-1 && +__STDLIB_MB_LEN_MAX + > __bos (__s)) + +94  + `__womb_chk + ( +__s +, +__wch +, + `__bos + (__s)); + +95  + `__womb_s + ( +__s +, +__wch +); + +96 + } +} + +99 +size_t + + $__mbowcs_chk + ( +wch_t + * +__ri + +__d +, + +100 +__cڡ + * +__ri + +__c +, + +101 +size_t + +__n +, size_ +__dn + +__THROW +; + +102 +size_t + + `__REDIRECT_NTH + ( +__mbowcs_s +, + +103 ( +wch_t + * +__ri + +__d +, + +104 +__cڡ + * +__ri + +__c +, + +105 +size_t + +__n +), +mbowcs +); + +106 +size_t + + `__REDIRECT_NTH + ( +__mbowcs_chk_wn +, + +107 ( +wch_t + * +__ri + +__d +, + +108 +__cڡ + * +__ri + +__c +, + +109 +size_t + +__n +, size_ +__dn +), +__mbowcs_chk +) + +110 + `__wljr + ("mbstowcs called with dst buffer smallerhanen " + +113 +__ex_ways_le + +size_t + + +114 + `__NTH + ( + $mbowcs + ( +wch_t + * +__ri + +__d +, +__cڡ + *__ri +__c +, + +115 +size_t + +__n +)) + +117 i( + `__bos + ( +__d +!( +size_t +) -1) + +119 i(! + `__but_cڡt_p + ( +__n +)) + +120  + `__mbowcs_chk + ( +__d +, +__c +, +__n +, + +121 + `__bos + ( +__d +/  ( +wch_t +)); + +123 i( +__n + > + `__bos + ( +__d +/  ( +wch_t +)) + +124  + `__mbowcs_chk_wn + ( +__d +, +__c +, +__n +, + +125 + `__bos + ( +__d +/  ( +wch_t +)); + +127  + `__mbowcs_s + ( +__d +, +__c +, +__n +); + +128 + } +} + +131 +size_t + + $__wcombs_chk + (* +__ri + +__d +, + +132 +__cڡ + +wch_t + * +__ri + +__c +, + +133 +size_t + +__n +, size_ +__dn + +__THROW +; + +134 +size_t + + `__REDIRECT_NTH + ( +__wcombs_s +, + +135 (* +__ri + +__d +, + +136 +__cڡ + +wch_t + * +__ri + +__c +, + +137 +size_t + +__n +), +wcombs +); + +138 +size_t + + `__REDIRECT_NTH + ( +__wcombs_chk_wn +, + +139 (* +__ri + +__d +, + +140 +__cڡ + +wch_t + * +__ri + +__c +, + +141 +size_t + +__n +, size_ +__dn +), +__wcombs_chk +) + +142 + `__wljr + ("wcstombs called with dst buffer smallerhanen"); + +144 +__ex_ways_le + +size_t + + +145 + `__NTH + ( + $wcombs + (* +__ri + +__d +, +__cڡ + +wch_t + *__ri +__c +, + +146 +size_t + +__n +)) + +148 i( + `__bos + ( +__d +!( +size_t +) -1) + +150 i(! + `__but_cڡt_p + ( +__n +)) + +151  + `__wcombs_chk + ( +__d +, +__c +, +__n +, + `__bos + (__dst)); + +152 i( +__n + > + `__bos + ( +__d +)) + +153  + `__wcombs_chk_wn + ( +__d +, +__c +, +__n +, + `__bos + (__dst)); + +155  + `__wcombs_s + ( +__d +, +__c +, +__n +); + +156 + } +} + + @/usr/include/bits/waitflags.h + +20 #i! +defed + +_SYS_WAIT_H + && !defed +_STDLIB_H + + +26  + #WNOHANG + 1 + + ) + +27  + #WUNTRACED + 2 + + ) + +30  + #WSTOPPED + 2 + + ) + +31  + #WEXITED + 4 + + ) + +32  + #WCONTINUED + 8 + + ) + +33  + #WNOWAIT + 0x01000000 + + ) + +35  + #__WNOTHREAD + 0x20000000 + + ) + +37  + #__WALL + 0x40000000 + + ) + +38  + #__WCLONE + 0x80000000 + + ) + + @/usr/include/bits/waitstatus.h + +20 #i! +defed + +_SYS_WAIT_H + && !defed +_STDLIB_H + + +29  + #__WEXITSTATUS +( +us +(((us& 0xff00>> 8) + + ) + +32  + #__WTERMSIG +( +us +((us& 0x7f) + + ) + +35  + #__WSTOPSIG +( +us + + `__WEXITSTATUS +(us) + + ) + +38  + #__WIFEXITED +( +us +( + `__WTERMSIG +(us=0) + + ) + +41  + #__WIFSIGNALED +( +us +) \ + +42 (((sigd ((( +us +& 0x7f+ 1>> 1> 0) + + ) + +45  + #__WIFSTOPPED +( +us +(((us& 0xff=0x7f) + + ) + +49 #ifde +WCONTINUED + + +50  + #__WIFCONTINUED +( +us +((us= +__W_CONTINUED +) + + ) + +54  + #__WCOREDUMP +( +us +((us& +__WCOREFLAG +) + + ) + +57  + #__W_EXITCODE +( +t +, +sig +(ԑ<< 8 | (sig)) + + ) + +58  + #__W_STOPCODE +( +sig +((sig<< 8 | 0x7f) + + ) + +59  + #__W_CONTINUED + 0xffff + + ) + +60  + #__WCOREFLAG + 0x80 + + ) + +63 #ifdef +__USE_BSD + + +65  + ~ + +67  + uwa + + +69  + mw_us +; + +72 #if +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +73  + m__w_rmsig +:7; + +74  + m__w_cedump +:1; + +75  + m__w_tcode +:8; + +78 #if +__BYTE_ORDER + = +__BIG_ENDIAN + + +80  + m__w_tcode +:8; + +81  + m__w_cedump +:1; + +82  + m__w_rmsig +:7; + +84 } + m__wa_rmed +; + +87 #if +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +88  + m__w_v +:8; + +89  + m__w_sig +:8; + +92 #if +__BYTE_ORDER + = +__BIG_ENDIAN + + +94  + m__w_sig +:8; + +95  + m__w_v +:8; + +97 } + m__wa_ݳd +; + +100  + #w_rmsig + +__wa_rmed +. +__w_rmsig + + + ) + +101  + #w_cedump + +__wa_rmed +. +__w_cedump + + + ) + +102  + #w_tcode + +__wa_rmed +. +__w_tcode + + + ) + +103  + #w_sig + +__wa_ݳd +. +__w_sig + + + ) + +104  + #w_v + +__wa_ݳd +. +__w_v + + + ) + + @/usr/include/gconv.h + +23 #ide +_GCONV_H + + +24  + #_GCONV_H + 1 + + ) + +26  + ~ + +27  + #__ed_mbe_t + + + ) + +28  + #__ed_wt_t + + + ) + +29  + ~ + +30  + #__ed_size_t + + + ) + +31  + #__ed_wch_t + + + ) + +32  + ~ + +35  + #__UNKNOWN_10646_CHAR + (( +wch_t +0xfffd) + + ) + +40 + m__GCONV_OK + = 0, + +41 + m__GCONV_NOCONV +, + +42 + m__GCONV_NODB +, + +43 + m__GCONV_NOMEM +, + +45 + m__GCONV_EMPTY_INPUT +, + +46 + m__GCONV_FULL_OUTPUT +, + +47 + m__GCONV_ILLEGAL_INPUT +, + +48 + m__GCONV_INCOMPLETE_INPUT +, + +50 + m__GCONV_ILLEGAL_DESCRIPTOR +, + +51 + m__GCONV_INTERNAL_ERROR + + +58 + m__GCONV_IS_LAST + = 0x0001, + +59 + m__GCONV_IGNORE_ERRORS + = 0x0002 + +64  + g__gcv_ +; + +65  + g__gcv__da +; + +66  + g__gcv_lded_obje +; + +67  + g__gcv_s_da +; + +71 (* + t__gcv_f +( + t__gcv_ + *,  + t__gcv__da + *, + +72 + t__cڡ + **, __const *, + +73 **, + tsize_t + *, , ); + +76  + $wt_t + (* + t__gcv_btowc_f +( + t__gcv_ + *, ); + +79 (* + t__gcv__f +( + t__gcv_ + *); + +80 (* + t__gcv_d_f +( + t__gcv_ + *); + +84 (* + t__gcv_s_f +( + t__gcv_ + *, + +85  + t__gcv__da + *, *, + +86 + t__cڡ + *, + +87 + t__cڡ + **, + +88 + t__cڡ + *, **, + +89 + tsize_t + *); + +92 (* + t__gcv_s_cڋxt_f +(*, + t__cڡ + *, + +93 + t__cڡ + *, + +97 (* + t__gcv_s_quy_f +( + t__cڡ + *, __const ***, + +98 + tsize_t + *); + +101 (* + t__gcv_s__f +) (**, const *); + +102 (* + t__gcv_s_d_f +) (*); + +104  + s__gcv_s_da + + +107 +__gcv_s_f + +__s_f +; + +108 +__gcv_s_cڋxt_f + +__s_cڋxt_f +; + +109 +__gcv_s_d_f + +__s_d_f +; + +110 * +__da +; + +111  +__gcv_s_da + * +__xt +; + +116  + s__gcv_ + + +118  +__gcv_lded_obje + * +__shlib_hd +; + +119 +__cڡ + * +__modme +; + +121  +__cou +; + +123 * +__om_me +; + +124 * +__to_me +; + +126 +__gcv_f + +__f +; + +127 +__gcv_btowc_f + +__btowc_f +; + +128 +__gcv__f + +___f +; + +129 +__gcv_d_f + +__d_f +; + +133  +__m_eded_om +; + +134  +__max_eded_om +; + +135  +__m_eded_to +; + +136  +__max_eded_to +; + +139  +__eful +; + +141 * +__da +; + +146  + s__gcv__da + + +148 * +__outbuf +; + +149 * +__outbund +; + +153  +__ags +; + +157  +__voti_cou +; + +161  +___u +; + +163 +__mbe_t + * +__ +; + +164 +__mbe_t + +__e +; + +168  +__gcv_s_da + * +__s +; + +173  + s__gcv_fo + + +175 +size_t + +__ns +; + +176  +__gcv_ + * +__s +; + +177 +__exnsi__ +  +__gcv__da + +__da + +__exr +; + +178 } * + t__gcv_t +; + + @/usr/include/gnu/stubs-32.h + +6 #ifde +_LIBC + + +7 #r +Alitis + +may + +n + +defe + +the + +mao + +_LIBC + + +10  + #__ub___kl_co + + + ) + +11  + #__ub___kl_sl + + + ) + +12  + #__ub___kl_ + + + ) + +13  + #__ub_chags + + + ) + +14  + #__ub_ach + + + ) + +15  + #__ub_fchags + + + ) + +16  + #__ub_fdach + + + ) + +17  + #__ub_gy + + + ) + +18  + #__ub_lchmod + + + ) + +19  + #__ub_voke + + + ) + +20  + #__ub_og + + + ) + +21  + #__ub_sigtu + + + ) + +22  + #__ub_sk + + + ) + +23  + #__ub_ty + + + ) + + @/usr/include/gnu/stubs-64.h + +6 #ifde +_LIBC + + +7 #r +Alitis + +may + +n + +defe + +the + +mao + +_LIBC + + +10  + #__ub_bdush + + + ) + +11  + #__ub_chags + + + ) + +12  + #__ub_ach + + + ) + +13  + #__ub_fchags + + + ) + +14  + #__ub_fdach + + + ) + +15  + #__ub_gmsg + + + ) + +16  + #__ub_gy + + + ) + +17  + #__ub_lchmod + + + ) + +18  + #__ub_putmsg + + + ) + +19  + #__ub_voke + + + ) + +20  + #__ub_og + + + ) + +21  + #__ub_sigtu + + + ) + +22  + #__ub_sk + + + ) + +23  + #__ub_ty + + + ) + + @/usr/include/sys/types.h + +24 #idef +_SYS_TYPES_H + + +25  + #_SYS_TYPES_H + 1 + + ) + +27  + ~ + +29 + g__BEGIN_DECLS + + +31  + ~ + +33 #ifdef +__USE_BSD + + +34 #ide +__u_ch_defed + + +35  +__u_ch + + tu_ch +; + +36  +__u_sht + + tu_sht +; + +37  +__u_t + + tu_t +; + +38  +__u_lg + + tu_lg +; + +39  +__quad_t + + tquad_t +; + +40  +__u_quad_t + + tu_quad_t +; + +41  +__fsid_t + + tfsid_t +; + +42  + #__u_ch_defed + + + ) + +46  +__loff_t + + tloff_t +; + +48 #ide +__o_t_defed + + +49 #ide +__USE_FILE_OFFSET64 + + +50  +__o_t + + to_t +; + +52  +__o64_t + + to_t +; + +54  + #__o_t_defed + + + ) + +56 #i +defed + +__USE_LARGEFILE64 + && !defed +__o64_t_defed + + +57  +__o64_t + + to64_t +; + +58  + #__o64_t_defed + + + ) + +61 #ide +__dev_t_defed + + +62  +__dev_t + + tdev_t +; + +63  + #__dev_t_defed + + + ) + +66 #ide +__gid_t_defed + + +67  +__gid_t + + tgid_t +; + +68  + #__gid_t_defed + + + ) + +71 #ide +__mode_t_defed + + +72  +__mode_t + + tmode_t +; + +73  + #__mode_t_defed + + + ) + +76 #ide +__ƚk_t_defed + + +77  +__ƚk_t + + tƚk_t +; + +78  + #__ƚk_t_defed + + + ) + +81 #ide +__uid_t_defed + + +82  +__uid_t + + tuid_t +; + +83  + #__uid_t_defed + + + ) + +86 #ide +__off_t_defed + + +87 #ide +__USE_FILE_OFFSET64 + + +88  +__off_t + + toff_t +; + +90  +__off64_t + + toff_t +; + +92  + #__off_t_defed + + + ) + +94 #i +defed + +__USE_LARGEFILE64 + && !defed +__off64_t_defed + + +95  +__off64_t + + toff64_t +; + +96  + #__off64_t_defed + + + ) + +99 #ide +__pid_t_defed + + +100  +__pid_t + + tpid_t +; + +101  + #__pid_t_defed + + + ) + +104 #i( +defed + +__USE_SVID + || defed +__USE_XOPEN +&& !defed +__id_t_defed + + +105  +__id_t + + tid_t +; + +106  + #__id_t_defed + + + ) + +109 #ide +__ssize_t_defed + + +110  +__ssize_t + + tssize_t +; + +111  + #__ssize_t_defed + + + ) + +114 #ifdef +__USE_BSD + + +115 #ide +__daddr_t_defed + + +116  +__daddr_t + + tdaddr_t +; + +117  +__ddr_t + + tddr_t +; + +118  + #__daddr_t_defed + + + ) + +122 #i( +defed + +__USE_SVID + || defed +__USE_XOPEN +&& !defed +__key_t_defed + + +123  +__key_t + + tkey_t +; + +124  + #__key_t_defed + + + ) + +127 #ifde +__USE_XOPEN + + +128  + #__ed_ock_t + + + ) + +130  + #__ed_time_t + + + ) + +131  + #__ed_tim_t + + + ) + +132  + #__ed_ockid_t + + + ) + +133  + ~ + +135 #ifde +__USE_XOPEN + + +136 #ide +__ucds_t_defed + + +137  +__ucds_t + + tucds_t +; + +138  + #__ucds_t_defed + + + ) + +140 #ide +__sucds_t_defed + + +141  +__sucds_t + + tsucds_t +; + +142  + #__sucds_t_defed + + + ) + +146  + #__ed_size_t + + + ) + +147  + ~ + +149 #ifde +__USE_MISC + + +151  + tulg +; + +152  + tusht +; + +153  + tut +; + +158 #i! +__GNUC_PREREQ + (2, 7) + +161 #ide +__t8_t_defed + + +162  + #__t8_t_defed + + + ) + +163  + tt8_t +; + +164  + tt16_t +; + +165  + tt32_t +; + +166 #i +__WORDSIZE + == 64 + +167  + tt64_t +; + +168 #i +__GLIBC_HAVE_LONG_LONG + + +169 +__exnsi__ +  + tt64_t +; + +174  + tu_t8_t +; + +175  + tu_t16_t +; + +176  + tu_t32_t +; + +177 #i +__WORDSIZE + == 64 + +178  + tu_t64_t +; + +179 #i +__GLIBC_HAVE_LONG_LONG + + +180 +__exnsi__ +  + tu_t64_t +; + +183  + tgi_t +; + +188  + #__tN_t +( +N +, +MODE +) \ + +189 ## + tN +## + t_t + + t__ibu__ + (( + t__mode__ + ( + tMODE +))) + + ) + +190  + t__u_tN_t +( + tN +, + tMODE +) \ + +191  + tu_t +## + tN +## + t_t + + t__ibu__ + (( + t__mode__ + ( + tMODE +))) + + ) + +193 #ide + t__t8_t_defed + + +194  + t__t8_t_defed + + + ) + +195 + t__tN_t + (8, + t__QI__ +); + +196 +__tN_t + (16, +__HI__ +); + +197 +__tN_t + (32, +__SI__ +); + +198 +__tN_t + (64, +__DI__ +); + +201 +__u_tN_t + (8, +__QI__ +); + +202 +__u_tN_t + (16, +__HI__ +); + +203 +__u_tN_t + (32, +__SI__ +); + +204 +__u_tN_t + (64, +__DI__ +); + +206  + tgi_t + + t__ibu__ + (( + t__mode__ + ( + t__wd__ +))); + +212  + #__BIT_TYPES_DEFINED__ + 1 + + ) + +215 #ifdef +__USE_BSD + + +217  + ~ + +220  + ~ + +223  + ~ + +227 #i +defed + +__USE_UNIX98 + && !defed +__blksize_t_defed + + +228  +__blksize_t + + tblksize_t +; + +229  + #__blksize_t_defed + + + ) + +233 #ide +__USE_FILE_OFFSET64 + + +234 #ide +__blkt_t_defed + + +235  +__blkt_t + + tblkt_t +; + +236  + #__blkt_t_defed + + + ) + +238 #ide +__fsblkt_t_defed + + +239  +__fsblkt_t + + tfsblkt_t +; + +240  + #__fsblkt_t_defed + + + ) + +242 #ide +__fsft_t_defed + + +243  +__fsft_t + + tfsft_t +; + +244  + #__fsft_t_defed + + + ) + +247 #ide +__blkt_t_defed + + +248  +__blkt64_t + + tblkt_t +; + +249  + #__blkt_t_defed + + + ) + +251 #ide +__fsblkt_t_defed + + +252  +__fsblkt64_t + + tfsblkt_t +; + +253  + #__fsblkt_t_defed + + + ) + +255 #ide +__fsft_t_defed + + +256  +__fsft64_t + + tfsft_t +; + +257  + #__fsft_t_defed + + + ) + +261 #ifde +__USE_LARGEFILE64 + + +262  +__blkt64_t + + tblkt64_t +; + +263  +__fsblkt64_t + + tfsblkt64_t +; + +264  +__fsft64_t + + tfsft64_t +; + +269 #i +defed + +__USE_POSIX199506 + || defed +__USE_UNIX98 + + +270  + ~ + +273 + g__END_DECLS + + + @/usr/include/wchar.h + +24 #ide +_WCHAR_H + + +26 #i! +defed + +__ed_mbe_t + && !defed +__ed_wt_t + + +27  + #_WCHAR_H + 1 + + ) + +28  + ~ + +31 #ifde +_WCHAR_H + + +33  + #__ed___FILE + + + ) + +34 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +35  + #__ed_FILE + + + ) + +37  + ~ + +39  + #__ed___va_li + + + ) + +40  + ~ + +42  + ~ + +45  + #__ed_size_t + + + ) + +46  + #__ed_wch_t + + + ) + +47  + #__ed_NULL + + + ) + +49 #i +defed + +_WCHAR_H + || defed +__ed_wt_t + || !defed +__WINT_TYPE__ + + +50 #unde +__ed_wt_t + + +51  + #__ed_wt_t + + + ) + +52  + ~ + +55 #i +defed + +__lulus + && +__GNUC_PREREQ + (4, 4) + +56  + #__CORRECT_ISO_CPP_WCHAR_H_PROTO + + + ) + +61 #ide +_WINT_T + + +66  + #_WINT_T + + + ) + +67  + twt_t +; + +71 #i +defed + +__lulus + && defed +_GLIBCPP_USE_NAMESPACES + \ + +72 && +defed + +__WINT_TYPE__ + + +73 +__BEGIN_NAMESPACE_STD + + +74  +__WINT_TYPE__ + + twt_t +; + +75 + g__END_NAMESPACE_STD + + +80 #i( +defed + +_WCHAR_H + || defed +__ed_mbe_t +&& !defed +__mbe_t_defed + + +81  + #__mbe_t_defed + 1 + + ) + +85  + m__cou +; + +88 #ifde +__WINT_TYPE__ + + +89 +__WINT_TYPE__ + + m__wch +; + +91 +wt_t + + m__wch +; + +93  + m__wchb +[4]; + +94 } + m__vue +; + +95 } + t__mbe_t +; + +97 #unde +__ed_mbe_t + + +102 #ifde +_WCHAR_H + + +104 +__BEGIN_NAMESPACE_C99 + + +106  +__mbe_t + + tmbe_t +; + +107 + g__END_NAMESPACE_C99 + + +108 #ifde +__USE_GNU + + +109 + $__USING_NAMESPACE_C99 +( +mbe_t +) + +112 #ide +WCHAR_MIN + + +114  + #WCHAR_MIN + +__WCHAR_MIN + + + ) + +115  + #WCHAR_MAX + +__WCHAR_MAX + + + ) + +118 #ide +WEOF + + +119  + #WEOF + (0xffffffffu) + + ) + +124 #i +defed + +__USE_XOPEN + && !defed +__USE_UNIX98 + + +125  + ~ + +129 +__BEGIN_DECLS + + +131 +__BEGIN_NAMESPACE_STD + + +134  +tm +; + +135 +__END_NAMESPACE_STD + + +139 + $__USING_NAMESPACE_STD +( +tm +) + +142 +__BEGIN_NAMESPACE_STD + + +144 +wch_t + * + $wcsy + ( +wch_t + * +__ri + +__de +, + +145 +__cڡ + +wch_t + * +__ri + +__c + +__THROW +; + +147 +wch_t + * + $wcy + ( +wch_t + * +__ri + +__de +, + +148 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +) + +149 +__THROW +; + +152 +wch_t + * + $wcst + ( +wch_t + * +__ri + +__de +, + +153 +__cڡ + +wch_t + * +__ri + +__c + +__THROW +; + +155 +wch_t + * + $wct + ( +wch_t + * +__ri + +__de +, + +156 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +) + +157 +__THROW +; + +160  + $wcscmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +) + +161 +__THROW + +__ibu_pu__ +; + +163  + $wccmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, +size_t + +__n +) + +164 +__THROW + +__ibu_pu__ +; + +165 +__END_NAMESPACE_STD + + +167 #ifde +__USE_XOPEN2K8 + + +169  + $wcscmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 + +__THROW +; + +172  + $wccmp + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +173 +size_t + +__n + +__THROW +; + +177  + ~ + +179  + $wcscmp_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +180 +__lo_t + +__loc + +__THROW +; + +182  + $wccmp_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +183 +size_t + +__n +, +__lo_t + +__loc + +__THROW +; + +186 +__BEGIN_NAMESPACE_STD + + +189  + $wcscl + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 + +__THROW +; + +193 +size_t + + $wcsxm + ( +wch_t + * +__ri + +__s1 +, + +194 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n + +__THROW +; + +195 +__END_NAMESPACE_STD + + +197 #ifde +__USE_XOPEN2K8 + + +203  + $wcscl_l + ( +__cڡ + +wch_t + * +__s1 +, __cڡ wch_* +__s2 +, + +204 +__lo_t + +__loc + +__THROW +; + +209 +size_t + + $wcsxm_l + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, + +210 +size_t + +__n +, +__lo_t + +__loc + +__THROW +; + +213 +wch_t + * + $wcsdup + ( +__cڡ + +wch_t + * +__s + +__THROW + +__ibu_mloc__ +; + +216 +__BEGIN_NAMESPACE_STD + + +218 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +219 "C++" +wch_t + * + $wcschr + ( +wch_t + * +__wcs +, wch_ +__wc +) + +220 +__THROW + + `__asm + ("wcschr" +__ibu_pu__ +; + +221 "C++" +__cڡ + +wch_t + * + $wcschr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +222 +__THROW + + `__asm + ("wcschr" +__ibu_pu__ +; + +224 +wch_t + * + $wcschr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +225 +__THROW + +__ibu_pu__ +; + +228 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +229 "C++" +wch_t + * + $wcchr + ( +wch_t + * +__wcs +, wch_ +__wc +) + +230 +__THROW + + `__asm + ("wcchr" +__ibu_pu__ +; + +231 "C++" +__cڡ + +wch_t + * + $wcchr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +232 +__THROW + + `__asm + ("wcchr" +__ibu_pu__ +; + +234 +wch_t + * + $wcchr + ( +__cڡ + +wch_t + * +__wcs +, wch_ +__wc +) + +235 +__THROW + +__ibu_pu__ +; + +237 +__END_NAMESPACE_STD + + +239 #ifde +__USE_GNU + + +242 +wch_t + * + $wcschul + ( +__cڡ + +wch_t + * +__s +, wch_ +__wc +) + +243 +__THROW + +__ibu_pu__ +; + +246 +__BEGIN_NAMESPACE_STD + + +249 +size_t + + $wcscn + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__je +) + +250 +__THROW + +__ibu_pu__ +; + +253 +size_t + + $wcsn + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__ac +) + +254 +__THROW + +__ibu_pu__ +; + +256 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +257 "C++" +wch_t + * + $wcbrk + ( +wch_t + * +__wcs +, +__cڡ + wch_* +__ac +) + +258 +__THROW + + `__asm + ("wcbrk" +__ibu_pu__ +; + +259 "C++" +__cڡ + +wch_t + * + $wcbrk + ( +__cڡ + +wch_t + * +__wcs +, + +260 +__cڡ + +wch_t + * +__ac +) + +261 +__THROW + + `__asm + ("wcbrk" +__ibu_pu__ +; + +263 +wch_t + * + $wcbrk + ( +__cڡ + +wch_t + * +__wcs +, __cڡ wch_* +__ac +) + +264 +__THROW + +__ibu_pu__ +; + +267 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +268 "C++" +wch_t + * + $wcsr + ( +wch_t + * +__hayack +, +__cڡ + wch_* +__ed +) + +269 +__THROW + + `__asm + ("wcsr" +__ibu_pu__ +; + +270 "C++" +__cڡ + +wch_t + * + $wcsr + ( +__cڡ + +wch_t + * +__hayack +, + +271 +__cڡ + +wch_t + * +__ed +) + +272 +__THROW + + `__asm + ("wcsr" +__ibu_pu__ +; + +274 +wch_t + * + $wcsr + ( +__cڡ + +wch_t + * +__hayack +, __cڡ wch_* +__ed +) + +275 +__THROW + +__ibu_pu__ +; + +279 +wch_t + * + $wcok + ( +wch_t + * +__ri + +__s +, + +280 +__cڡ + +wch_t + * +__ri + +__dim +, + +281 +wch_t + ** +__ri + +__r + +__THROW +; + +284 +size_t + + $wc + ( +__cڡ + +wch_t + * +__s + +__THROW + +__ibu_pu__ +; + +285 +__END_NAMESPACE_STD + + +287 #ifde +__USE_XOPEN + + +289 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +290 "C++" +wch_t + * + $wcswcs + ( +wch_t + * +__hayack +, +__cڡ + wch_* +__ed +) + +291 +__THROW + + `__asm + ("wcswcs" +__ibu_pu__ +; + +292 "C++" +__cڡ + +wch_t + * + $wcswcs + ( +__cڡ + +wch_t + * +__hayack +, + +293 +__cڡ + +wch_t + * +__ed +) + +294 +__THROW + + `__asm + ("wcswcs" +__ibu_pu__ +; + +296 +wch_t + * + $wcswcs + ( +__cڡ + +wch_t + * +__hayack +, __cڡ wch_* +__ed +) + +297 +__THROW + +__ibu_pu__ +; + +301 #ifde +__USE_XOPEN2K8 + + +303 +size_t + + $wcn + ( +__cڡ + +wch_t + * +__s +, +size_t + +__maxn +) + +304 +__THROW + +__ibu_pu__ +; + +308 +__BEGIN_NAMESPACE_STD + + +310 #ifde +__CORRECT_ISO_CPP_WCHAR_H_PROTO + + +311 "C++" +wch_t + * + $wmemchr + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +) + +312 +__THROW + + `__asm + ("wmemchr" +__ibu_pu__ +; + +313 "C++" +__cڡ + +wch_t + * + $wmemchr + ( +__cڡ + +wch_t + * +__s +, wch_ +__c +, + +314 +size_t + +__n +) + +315 +__THROW + + `__asm + ("wmemchr" +__ibu_pu__ +; + +317 +wch_t + * + $wmemchr + ( +__cڡ + +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +) + +318 +__THROW + +__ibu_pu__ +; + +322  + $wmemcmp + ( +__cڡ + +wch_t + * +__ri + +__s1 +, + +323 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +) + +324 +__THROW + +__ibu_pu__ +; + +327 +wch_t + * + $wmemy + ( +wch_t + * +__ri + +__s1 +, + +328 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n + +__THROW +; + +332 +wch_t + * + $wmemmove + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, +size_t + +__n +) + +333 +__THROW +; + +336 +wch_t + * + $wmemt + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n + +__THROW +; + +337 +__END_NAMESPACE_STD + + +339 #ifde +__USE_GNU + + +342 +wch_t + * + $wmempy + ( +wch_t + * +__ri + +__s1 +, + +343 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +) + +344 +__THROW +; + +348 +__BEGIN_NAMESPACE_STD + + +351 +wt_t + + $btowc + ( +__c + +__THROW +; + +355  + $wob + ( +wt_t + +__c + +__THROW +; + +359  + $mbs + ( +__cڡ + +mbe_t + * +__ps + +__THROW + +__ibu_pu__ +; + +363 +size_t + + $mbowc + ( +wch_t + * +__ri + +__pwc +, + +364 +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +365 +mbe_t + * +__p + +__THROW +; + +368 +size_t + + $wtomb + (* +__ri + +__s +, +wch_t + +__wc +, + +369 +mbe_t + * +__ri + +__ps + +__THROW +; + +372 +size_t + + $__mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +373 +mbe_t + * +__ri + +__ps + +__THROW +; + +374 +size_t + + $mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +375 +mbe_t + * +__ri + +__ps + +__THROW +; + +376 +__END_NAMESPACE_STD + + +378 #ifde +__USE_EXTERN_INLINES + + +384 +wt_t + + $__btowc_s + ( +__c + + `__asm + ("btowc"); + +385 +__ex_le + +wt_t + + +386 + `__NTH + ( + $btowc + ( +__c +)) + +387 {  ( + `__but_cڡt_p + ( +__c +) && __c >= '\0' && __c <= '\x7f' + +388 ? ( +wt_t + +__c + : + `__btowc_s + (__c)); + } +} + +390  + $__wob_s + ( +wt_t + +__c + + `__asm + ("wctob"); + +391 +__ex_le +  + +392 + `__NTH + ( + $wob + ( +wt_t + +__wc +)) + +393 {  ( + `__but_cڡt_p + ( +__wc +&& __w> +L +'\0' && __wc <= L'\x7f' + +394 ? ( +__wc + : + `__wob_s + (__wc)); + } +} + +396 +__ex_le + +size_t + + +397 +__NTH + ( + $mb + ( +__cڡ + * +__ri + +__s +, +size_t + +__n +, + +398 +mbe_t + * +__ri + +__ps +)) + +399 {  ( +__ps + ! +NULL + + +400 ? + `mbowc + ( +NULL +, +__s +, +__n +, +__ps +: + `__mb + (__s, __n, NULL)); + } +} + +403 +__BEGIN_NAMESPACE_STD + + +406 +size_t + + $mbtowcs + ( +wch_t + * +__ri + +__d +, + +407 +__cڡ + ** +__ri + +__c +, +size_t + +__n +, + +408 +mbe_t + * +__ri + +__ps + +__THROW +; + +412 +size_t + + $wctombs + (* +__ri + +__d +, + +413 +__cڡ + +wch_t + ** +__ri + +__c +, +size_t + +__n +, + +414 +mbe_t + * +__ri + +__ps + +__THROW +; + +415 +__END_NAMESPACE_STD + + +418 #ifdef +__USE_XOPEN2K8 + + +421 +size_t + + $mbowcs + ( +wch_t + * +__ri + +__d +, + +422 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +423 +size_t + +__n +, +mbe_t + * +__ri + +__ps + +__THROW +; + +427 +size_t + + $wcombs + (* +__ri + +__d +, + +428 +__cڡ + +wch_t + ** +__ri + +__c +, + +429 +size_t + +__nwc +, size_ +__n +, + +430 +mbe_t + * +__ri + +__ps + +__THROW +; + +435 #ifde +__USE_XOPEN + + +437  + $wcwidth + ( +wch_t + +__c + +__THROW +; + +441  + $wcswidth + ( +__cڡ + +wch_t + * +__s +, +size_t + +__n + +__THROW +; + +445 +__BEGIN_NAMESPACE_STD + + +448  + $wcod + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +449 +wch_t + ** +__ri + +__dr + +__THROW +; + +450 +__END_NAMESPACE_STD + + +452 #ifde +__USE_ISOC99 + + +453 +__BEGIN_NAMESPACE_C99 + + +455  + $wcof + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +456 +wch_t + ** +__ri + +__dr + +__THROW +; + +457  + $wcd + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +458 +wch_t + ** +__ri + +__dr + +__THROW +; + +459 +__END_NAMESPACE_C99 + + +463 +__BEGIN_NAMESPACE_STD + + +466  + $wc + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +467 +wch_t + ** +__ri + +__dr +,  +__ba + +__THROW +; + +471  + $wcoul + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +472 +wch_t + ** +__ri + +__dr +,  +__ba +) + +473 +__THROW +; + +474 +__END_NAMESPACE_STD + + +476 #i +defed + +__USE_ISOC99 + || (defed +__GNUC__ + && defed +__USE_GNU +) + +477 +__BEGIN_NAMESPACE_C99 + + +480 +__exnsi__ + + +481  + $wcl + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +482 +wch_t + ** +__ri + +__dr +,  +__ba +) + +483 +__THROW +; + +487 +__exnsi__ + + +488  + $wcou + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +489 +wch_t + ** +__ri + +__dr +, + +490  +__ba + +__THROW +; + +491 +__END_NAMESPACE_C99 + + +494 #i +defed + +__GNUC__ + && defed +__USE_GNU + + +497 +__exnsi__ + + +498  + $wcoq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +499 +wch_t + ** +__ri + +__dr +,  +__ba +) + +500 +__THROW +; + +504 +__exnsi__ + + +505  + $wcouq + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +506 +wch_t + ** +__ri + +__dr +, + +507  +__ba + +__THROW +; + +510 #ifde +__USE_GNU + + +524  + ~ + +528  + $wc_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +529 +wch_t + ** +__ri + +__dr +,  +__ba +, + +530 +__lo_t + +__loc + +__THROW +; + +532  + $wcoul_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +533 +wch_t + ** +__ri + +__dr +, + +534  +__ba +, +__lo_t + +__loc + +__THROW +; + +536 +__exnsi__ + + +537  + $wcl_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +538 +wch_t + ** +__ri + +__dr +, + +539  +__ba +, +__lo_t + +__loc + +__THROW +; + +541 +__exnsi__ + + +542  + $wcou_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +543 +wch_t + ** +__ri + +__dr +, + +544  +__ba +, +__lo_t + +__loc +) + +545 +__THROW +; + +547  + $wcod_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +548 +wch_t + ** +__ri + +__dr +, +__lo_t + +__loc +) + +549 +__THROW +; + +551  + $wcof_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +552 +wch_t + ** +__ri + +__dr +, +__lo_t + +__loc +) + +553 +__THROW +; + +555  + $wcd_l + ( +__cڡ + +wch_t + * +__ri + +__Ō +, + +556 +wch_t + ** +__ri + +__dr +, + +557 +__lo_t + +__loc + +__THROW +; + +561 #ifdef +__USE_XOPEN2K8 + + +564 +wch_t + * + $wy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c + +__THROW +; + +568 +wch_t + * + $wny + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +) + +569 +__THROW +; + +575 #ifdef +__USE_XOPEN2K8 + + +578 +__FILE + * + $ݒ_wmemam + ( +wch_t + ** +__buoc +, +size_t + * +__sizoc + +__THROW +; + +581 #i +defed + +__USE_ISOC95 + || defed +__USE_UNIX98 + + +582 +__BEGIN_NAMESPACE_STD + + +585  + $fwide + ( +__FILE + * +__ +,  +__mode + +__THROW +; + +592  + `fwtf + ( +__FILE + * +__ri + +__am +, + +593 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +599  + `wtf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +602  + $swtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +603 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +604 +__THROW + ; + +610  + `vfwtf + ( +__FILE + * +__ri + +__s +, + +611 +__cڡ + +wch_t + * +__ri + +__fm +, + +612 +__gnuc_va_li + +__g +) + +618  + `vwtf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +619 +__gnuc_va_li + +__g +) + +623  + $vswtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +624 +__cڡ + +wch_t + * +__ri + +__fm +, + +625 +__gnuc_va_li + +__g +) + +626 +__THROW + ; + +633  + `fwsnf + ( +__FILE + * +__ri + +__am +, + +634 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +640  + `wsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +643  + $swsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +644 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +645 +__THROW + ; + +647 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +648 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +649 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +650 #ifde +__REDIRECT + + +654  + `__REDIRECT + ( +fwsnf +, ( +__FILE + * +__ri + +__am +, + +655 +__cڡ + +wch_t + * +__ri + +__fm +, ...), + +656 +__isoc99_fwsnf +) + +658  + `__REDIRECT + ( +wsnf +, ( +__cڡ + +wch_t + * +__ri + +__fm +, ...), + +659 +__isoc99_wsnf +) + +661  + `__REDIRECT + ( +swsnf +, ( +__cڡ + +wch_t + * +__ri + +__s +, + +662 +__cڡ + +wch_t + * +__ri + +__fm +, ...), + +663 +__isoc99_swsnf +) + +664 +__THROW + ; + +666  + `__isoc99_fwsnf + ( +__FILE + * +__ri + +__am +, + +667 +__cڡ + +wch_t + * +__ri + +__fm +, ...); + +668  + `__isoc99_wsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, ...); + +669  + $__isoc99_swsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +670 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +671 +__THROW +; + +672  + #fwsnf + +__isoc99_fwsnf + + + ) + +673  + #wsnf + +__isoc99_wsnf + + + ) + +674  + #swsnf + +__isoc99_swsnf + + + ) + +678 +__END_NAMESPACE_STD + + +681 #ifde +__USE_ISOC99 + + +682 +__BEGIN_NAMESPACE_C99 + + +687  + `vfwsnf + ( +__FILE + * +__ri + +__s +, + +688 +__cڡ + +wch_t + * +__ri + +__fm +, + +689 +__gnuc_va_li + +__g +) + +695  + `vwsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +696 +__gnuc_va_li + +__g +) + +699  + $vswsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +700 +__cڡ + +wch_t + * +__ri + +__fm +, + +701 +__gnuc_va_li + +__g +) + +702 +__THROW + ; + +704 #i! +defed + +__USE_GNU + \ + +705 && (! +defed + +__LDBL_COMPAT + || !defed +__REDIRECT +) \ + +706 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +707 #ifde +__REDIRECT + + +708  + `__REDIRECT + ( +vfwsnf +, ( +__FILE + * +__ri + +__s +, + +709 +__cڡ + +wch_t + * +__ri + +__fm +, + +710 +__gnuc_va_li + +__g +), +__isoc99_vfwsnf +) + +712  + `__REDIRECT + ( +vwsnf +, ( +__cڡ + +wch_t + * +__ri + +__fm +, + +713 +__gnuc_va_li + +__g +), +__isoc99_vwsnf +) + +715  + `__REDIRECT + ( +vswsnf +, ( +__cڡ + +wch_t + * +__ri + +__s +, + +716 +__cڡ + +wch_t + * +__ri + +__fm +, + +717 +__gnuc_va_li + +__g +), +__isoc99_vswsnf +) + +718 +__THROW + ; + +720  + `__isoc99_vfwsnf + ( +__FILE + * +__ri + +__s +, + +721 +__cڡ + +wch_t + * +__ri + +__fm +, + +722 +__gnuc_va_li + +__g +); + +723  + `__isoc99_vwsnf + ( +__cڡ + +wch_t + * +__ri + +__fm +, + +724 +__gnuc_va_li + +__g +); + +725  + $__isoc99_vswsnf + ( +__cڡ + +wch_t + * +__ri + +__s +, + +726 +__cڡ + +wch_t + * +__ri + +__fm +, + +727 +__gnuc_va_li + +__g + +__THROW +; + +728  + #vfwsnf + +__isoc99_vfwsnf + + + ) + +729  + #vwsnf + +__isoc99_vwsnf + + + ) + +730  + #vswsnf + +__isoc99_vswsnf + + + ) + +734 +__END_NAMESPACE_C99 + + +738 +__BEGIN_NAMESPACE_STD + + +743 +wt_t + + `fgwc + ( +__FILE + * +__am +); + +744 +wt_t + + `gwc + ( +__FILE + * +__am +); + +750 +wt_t + + `gwch + (); + +757 +wt_t + + `utwc + ( +wch_t + +__wc +, +__FILE + * +__am +); + +758 +wt_t + + `putwc + ( +wch_t + +__wc +, +__FILE + * +__am +); + +764 +wt_t + + `putwch + ( +wch_t + +__wc +); + +772 +wch_t + * + `fgws + (wch_* +__ri + +__ws +,  +__n +, + +773 +__FILE + * +__ri + +__am +); + +779  + `utws + ( +__cڡ + +wch_t + * +__ri + +__ws +, + +780 +__FILE + * +__ri + +__am +); + +787 +wt_t + + `ungwc + (wt_ +__wc +, +__FILE + * +__am +); + +788 +__END_NAMESPACE_STD + + +791 #ifde +__USE_GNU + + +799 +wt_t + + `gwc_uocked + ( +__FILE + * +__am +); + +800 +wt_t + + `gwch_uocked + (); + +808 +wt_t + + `fgwc_uocked + ( +__FILE + * +__am +); + +816 +wt_t + + `utwc_uocked + ( +wch_t + +__wc +, +__FILE + * +__am +); + +825 +wt_t + + `putwc_uocked + ( +wch_t + +__wc +, +__FILE + * +__am +); + +826 +wt_t + + `putwch_uocked + ( +wch_t + +__wc +); + +835 +wch_t + * + `fgws_uocked + (wch_* +__ri + +__ws +,  +__n +, + +836 +__FILE + * +__ri + +__am +); + +844  + `utws_uocked + ( +__cڡ + +wch_t + * +__ri + +__ws +, + +845 +__FILE + * +__ri + +__am +); + +849 +__BEGIN_NAMESPACE_C99 + + +853 +size_t + + $wcsime + ( +wch_t + * +__ri + +__s +, +size_t + +__maxsize +, + +854 +__cڡ + +wch_t + * +__ri + +__fm +, + +855 +__cڡ +  +tm + * +__ri + +__ + +__THROW +; + +856 +__END_NAMESPACE_C99 + + +858 #ifde +__USE_GNU + + +859  + ~ + +863 +size_t + + $wcsime_l + ( +wch_t + * +__ri + +__s +, +size_t + +__maxsize +, + +864 +__cڡ + +wch_t + * +__ri + +__fm +, + +865 +__cڡ +  +tm + * +__ri + +__ +, + +866 +__lo_t + +__loc + +__THROW +; + +875 #i +defed + +__USE_UNIX98 + && !defed +__USE_GNU + + +876  + #__ed_iswxxx + + + ) + +877  + ~ + +881 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +882  + ~ + +885 #ifde +__LDBL_COMPAT + + +886  + ~ + +889 +__END_DECLS + + +897 #unde +__ed_mbe_t + + +898 #unde +__ed_wt_t + + + @/usr/include/bits/pthreadtypes.h + +20 #ide +_BITS_PTHREADTYPES_H + + +21  + #_BITS_PTHREADTYPES_H + 1 + + ) + +23  + ~ + +25 #i +__WORDSIZE + == 64 + +26  + #__SIZEOF_PTHREAD_ATTR_T + 56 + + ) + +27  + #__SIZEOF_PTHREAD_MUTEX_T + 40 + + ) + +28  + #__SIZEOF_PTHREAD_MUTEXATTR_T + 4 + + ) + +29  + #__SIZEOF_PTHREAD_COND_T + 48 + + ) + +30  + #__SIZEOF_PTHREAD_CONDATTR_T + 4 + + ) + +31  + #__SIZEOF_PTHREAD_RWLOCK_T + 56 + + ) + +32  + #__SIZEOF_PTHREAD_RWLOCKATTR_T + 8 + + ) + +33  + #__SIZEOF_PTHREAD_BARRIER_T + 32 + + ) + +34  + #__SIZEOF_PTHREAD_BARRIERATTR_T + 4 + + ) + +36  + #__SIZEOF_PTHREAD_ATTR_T + 36 + + ) + +37  + #__SIZEOF_PTHREAD_MUTEX_T + 24 + + ) + +38  + #__SIZEOF_PTHREAD_MUTEXATTR_T + 4 + + ) + +39  + #__SIZEOF_PTHREAD_COND_T + 48 + + ) + +40  + #__SIZEOF_PTHREAD_CONDATTR_T + 4 + + ) + +41  + #__SIZEOF_PTHREAD_RWLOCK_T + 32 + + ) + +42  + #__SIZEOF_PTHREAD_RWLOCKATTR_T + 8 + + ) + +43  + #__SIZEOF_PTHREAD_BARRIER_T + 20 + + ) + +44  + #__SIZEOF_PTHREAD_BARRIERATTR_T + 4 + + ) + +50  + thad_t +; + +55  + m__size +[ +__SIZEOF_PTHREAD_ATTR_T +]; + +56  + m__ign +; + +57 } + thad__t +; + +60 #i +__WORDSIZE + == 64 + +61  + s__had__li + + +63  +__had__li + * + m__ev +; + +64  +__had__li + * + m__xt +; + +65 } + t__had_li_t +; + +67  + s__had__i + + +69  +__had__i + * + m__xt +; + +70 } + t__had_i_t +; + +78  + s__had_mux_s + + +80  + m__lock +; + +81  + m__cou +; + +82  + m__owr +; + +83 #i +__WORDSIZE + == 64 + +84  + m__nurs +; + +88  + m__kd +; + +89 #i +__WORDSIZE + == 64 + +90  + m__s +; + +91 +__had_li_t + + m__li +; + +92  + #__PTHREAD_MUTEX_HAVE_PREV + 1 + + ) + +94  + m__nurs +; + +95 +__exnsi__ + union + +97  + m__s +; + +98 +__had_i_t + + m__li +; + +101 } + m__da +; + +102  + m__size +[ +__SIZEOF_PTHREAD_MUTEX_T +]; + +103  + m__ign +; + +104 } + thad_mux_t +; + +108  + m__size +[ +__SIZEOF_PTHREAD_MUTEXATTR_T +]; + +109  + m__ign +; + +110 } + thad_mux_t +; + +119  + m__lock +; + +120  + m__fux +; + +121 +__exnsi__ +  + m__tٮ_q +; + +122 +__exnsi__ +  + m__wakeup_q +; + +123 +__exnsi__ +  + m__wok_q +; + +124 * + m__mux +; + +125  + m__nwas +; + +126  + m__brd_q +; + +127 } + m__da +; + +128  + m__size +[ +__SIZEOF_PTHREAD_COND_T +]; + +129 +__exnsi__ +  + m__ign +; + +130 } + thad_cd_t +; + +134  + m__size +[ +__SIZEOF_PTHREAD_CONDATTR_T +]; + +135  + m__ign +; + +136 } + thad_cd_t +; + +140  + thad_key_t +; + +144  + thad__t +; + +147 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +152 #i +__WORDSIZE + == 64 + +155  + m__lock +; + +156  + m___ads +; + +157  + m__ads_wakeup +; + +158  + m__wr_wakeup +; + +159  + m___ads_queued +; + +160  + m___wrs_queued +; + +161  + m__wr +; + +162  + m__shed +; + +163  + m__d1 +; + +164  + m__d2 +; + +167  + m__ags +; + +168 } + m__da +; + +172  + m__lock +; + +173  + m___ads +; + +174  + m__ads_wakeup +; + +175  + m__wr_wakeup +; + +176  + m___ads_queued +; + +177  + m___wrs_queued +; + +180  + m__ags +; + +181  + m__shed +; + +182  + m__d1 +; + +183  + m__d2 +; + +184  + m__wr +; + +185 } + m__da +; + +187  + m__size +[ +__SIZEOF_PTHREAD_RWLOCK_T +]; + +188  + m__ign +; + +189 } + thad_rwlock_t +; + +193  + m__size +[ +__SIZEOF_PTHREAD_RWLOCKATTR_T +]; + +194  + m__ign +; + +195 } + thad_rwlock_t +; + +199 #ifde +__USE_XOPEN2K + + +201 vީ + thad_lock_t +; + +208  + m__size +[ +__SIZEOF_PTHREAD_BARRIER_T +]; + +209  + m__ign +; + +210 } + thad_brr_t +; + +214  + m__size +[ +__SIZEOF_PTHREAD_BARRIERATTR_T +]; + +215  + m__ign +; + +216 } + thad_brr_t +; + +220 #i +__WORDSIZE + == 32 + +222  + #__nup_f_ibu + + `__ibu__ + (( + `__grm__ + (1))) + + ) + + @/usr/include/bits/wchar-ldbl.h + +20 #ide +_WCHAR_H + + +24 #i +defed + +__USE_ISOC95 + || defed +__USE_UNIX98 + + +25 +__BEGIN_NAMESPACE_C99 + + +26 +__LDBL_REDIR_DECL + ( +fwtf +); + +27 +__LDBL_REDIR_DECL + ( +wtf +); + +28 +__LDBL_REDIR_DECL + ( +swtf +); + +29 +__LDBL_REDIR_DECL + ( +vfwtf +); + +30 +__LDBL_REDIR_DECL + ( +vwtf +); + +31 +__LDBL_REDIR_DECL + ( +vswtf +); + +32 #i +defed + +__USE_ISOC99 + && !defed +__USE_GNU + \ + +33 && ! +defed + + g__REDIRECT + \ + +34 && ( +defed + + g__STRICT_ANSI__ + || defed + g__USE_XOPEN2K +) + +35 + $__LDBL_REDIR1_DECL + ( +fwsnf +, +__dbl___isoc99_fwsnf +) + +36 + $__LDBL_REDIR1_DECL + ( +wsnf +, +__dbl___isoc99_wsnf +) + +37 + $__LDBL_REDIR1_DECL + ( +swsnf +, +__dbl___isoc99_swsnf +) + +39 + `__LDBL_REDIR_DECL + ( +fwsnf +); + +40 + `__LDBL_REDIR_DECL + ( +wsnf +); + +41 + `__LDBL_REDIR_DECL + ( +swsnf +); + +43 +__END_NAMESPACE_C99 + + +46 #ifde +__USE_ISOC99 + + +47 +__BEGIN_NAMESPACE_C99 + + +48 + `__LDBL_REDIR1_DECL + ( +wcd +, +wcod +); + +49 #i! +defed + +__USE_GNU + && !defed +__REDIRECT + \ + +50 && ( +defed + +__STRICT_ANSI__ + || defed +__USE_XOPEN2K +) + +51 + $__LDBL_REDIR1_DECL + ( +vfwsnf +, +__dbl___isoc99_vfwsnf +) + +52 + $__LDBL_REDIR1_DECL + ( +vwsnf +, +__dbl___isoc99_vwsnf +) + +53 + $__LDBL_REDIR1_DECL + ( +vswsnf +, +__dbl___isoc99_vswsnf +) + +55 + `__LDBL_REDIR_DECL + ( +vfwsnf +); + +56 + `__LDBL_REDIR_DECL + ( +vwsnf +); + +57 + `__LDBL_REDIR_DECL + ( +vswsnf +); + +59 +__END_NAMESPACE_C99 + + +62 #ifde +__USE_GNU + + +63 + `__LDBL_REDIR1_DECL + ( +wcd_l +, +wcod_l +); + +66 #i +__USE_FORTIFY_LEVEL + > 0 && +defed + +__ex_ways_le + + +67 + $__LDBL_REDIR_DECL + ( +__swtf_chk +) + +68 + $__LDBL_REDIR_DECL + ( +__vswtf_chk +) + +69 #i +__USE_FORTIFY_LEVEL + > 1 + +70 + $__LDBL_REDIR_DECL + ( +__fwtf_chk +) + +71 + $__LDBL_REDIR_DECL + ( +__wtf_chk +) + +72 + $__LDBL_REDIR_DECL + ( +__vfwtf_chk +) + +73 + $__LDBL_REDIR_DECL + ( +__vwtf_chk +) + + @/usr/include/bits/wchar.h + +20 #ide +_BITS_WCHAR_H + + +21  + #_BITS_WCHAR_H + 1 + + ) + +24 #ifde +__WCHAR_MAX__ + + +25  + #__WCHAR_MAX + +__WCHAR_MAX__ + + + ) + +27  + #__WCHAR_MAX + (2147483647) + + ) + +32 #ifde +__WCHAR_UNSIGNED__ + + +33  + #__WCHAR_MIN + +L +'\0' + + ) + +37 #i +L +'\0' - 1 > 0 + +38  + #__WCHAR_MIN + +L +'\0' + + ) + +40  + #__WCHAR_MIN + (- +__WCHAR_MAX + - 1) + + ) + + @/usr/include/bits/wchar2.h + +20 #ide +_WCHAR_H + + +25 +wch_t + * + $__wmemy_chk + ( +wch_t + * +__ri + +__s1 +, + +26 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +27 +size_t + +__ns1 + +__THROW +; + +28 +wch_t + * + `__REDIRECT_NTH + ( +__wmemy_s +, + +29 ( +wch_t + * +__ri + +__s1 +, + +30 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +), + +31 +wmemy +); + +32 +wch_t + * + `__REDIRECT_NTH + ( +__wmemy_chk_wn +, + +33 ( +wch_t + * +__ri + +__s1 +, + +34 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +35 +size_t + +__ns1 +), +__wmemy_chk +) + +36 + `__wljr + ("wmemcpy called withength biggerhan size of destination " + +39 +__ex_ways_le + +wch_t + * + +40 + `__NTH + ( + $wmemy + ( +wch_t + * +__ri + +__s1 +, +__cڡ + wch_*__ri +__s2 +, + +41 +size_t + +__n +)) + +43 i( + `__bos0 + ( +__s1 +!( +size_t +) -1) + +45 i(! + `__but_cڡt_p + ( +__n +)) + +46  + `__wmemy_chk + ( +__s1 +, +__s2 +, +__n +, + +47 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +49 i( +__n + > + `__bos0 + ( +__s1 +/  ( +wch_t +)) + +50  + `__wmemy_chk_wn + ( +__s1 +, +__s2 +, +__n +, + +51 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +53  + `__wmemy_s + ( +__s1 +, +__s2 +, +__n +); + +54 + } +} + +57 +wch_t + * + $__wmemmove_chk + ( +wch_t + * +__s1 +, +__cڡ + wch_* +__s2 +, + +58 +size_t + +__n +, size_ +__ns1 + +__THROW +; + +59 +wch_t + * + `__REDIRECT_NTH + ( +__wmemmove_s +, (wch_* +__s1 +, + +60 +__cڡ + +wch_t + * +__s2 +, + +61 +size_t + +__n +), +wmemmove +); + +62 +wch_t + * + `__REDIRECT_NTH + ( +__wmemmove_chk_wn +, + +63 ( +wch_t + * +__ri + +__s1 +, + +64 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +65 +size_t + +__ns1 +), +__wmemmove_chk +) + +66 + `__wljr + ("wmemmove called withength biggerhan size of destination " + +69 +__ex_ways_le + +wch_t + * + +70 + `__NTH + ( + $wmemmove + ( +wch_t + * +__ri + +__s1 +, +__cڡ + wch_*__ri +__s2 +, + +71 +size_t + +__n +)) + +73 i( + `__bos0 + ( +__s1 +!( +size_t +) -1) + +75 i(! + `__but_cڡt_p + ( +__n +)) + +76  + `__wmemmove_chk + ( +__s1 +, +__s2 +, +__n +, + +77 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +79 i( +__n + > + `__bos0 + ( +__s1 +/  ( +wch_t +)) + +80  + `__wmemmove_chk_wn + ( +__s1 +, +__s2 +, +__n +, + +81 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +83  + `__wmemmove_s + ( +__s1 +, +__s2 +, +__n +); + +84 + } +} + +87 #ifde +__USE_GNU + + +88 +wch_t + * + $__wmempy_chk + ( +wch_t + * +__ri + +__s1 +, + +89 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +90 +size_t + +__ns1 + +__THROW +; + +91 +wch_t + * + `__REDIRECT_NTH + ( +__wmempy_s +, + +92 ( +wch_t + * +__ri + +__s1 +, + +93 +__cڡ + +wch_t + * +__ri + +__s2 +, + +94 +size_t + +__n +), +wmempy +); + +95 +wch_t + * + `__REDIRECT_NTH + ( +__wmempy_chk_wn +, + +96 ( +wch_t + * +__ri + +__s1 +, + +97 +__cڡ + +wch_t + * +__ri + +__s2 +, +size_t + +__n +, + +98 +size_t + +__ns1 +), +__wmempy_chk +) + +99 + `__wljr + ("wmempcpy called withength biggerhan size of destination " + +102 +__ex_ways_le + +wch_t + * + +103 + `__NTH + ( + $wmempy + ( +wch_t + * +__ri + +__s1 +, +__cڡ + wch_*__ri +__s2 +, + +104 +size_t + +__n +)) + +106 i( + `__bos0 + ( +__s1 +!( +size_t +) -1) + +108 i(! + `__but_cڡt_p + ( +__n +)) + +109  + `__wmempy_chk + ( +__s1 +, +__s2 +, +__n +, + +110 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +112 i( +__n + > + `__bos0 + ( +__s1 +/  ( +wch_t +)) + +113  + `__wmempy_chk_wn + ( +__s1 +, +__s2 +, +__n +, + +114 + `__bos0 + ( +__s1 +/  ( +wch_t +)); + +116  + `__wmempy_s + ( +__s1 +, +__s2 +, +__n +); + +117 + } +} + +121 +wch_t + * + $__wmemt_chk + ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +, + +122 +size_t + +__ns + +__THROW +; + +123 +wch_t + * + `__REDIRECT_NTH + ( +__wmemt_s +, (wch_* +__s +, wch_ +__c +, + +124 +size_t + +__n +), +wmemt +); + +125 +wch_t + * + `__REDIRECT_NTH + ( +__wmemt_chk_wn +, + +126 ( +wch_t + * +__s +, wch_ +__c +, +size_t + +__n +, + +127 +size_t + +__ns +), +__wmemt_chk +) + +128 + `__wljr + ("wmemset called withength biggerhan size of destination " + +131 +__ex_ways_le + +wch_t + * + +132 + `__NTH + ( + $wmemt + ( +wch_t + * +__ri + +__s +, wch_ +__c +, +size_t + +__n +)) + +134 i( + `__bos0 + ( +__s +!( +size_t +) -1) + +136 i(! + `__but_cڡt_p + ( +__n +)) + +137  + `__wmemt_chk + ( +__s +, +__c +, +__n +, + `__bos0 + (__s/  ( +wch_t +)); + +139 i( +__n + > + `__bos0 + ( +__s +/  ( +wch_t +)) + +140  + `__wmemt_chk_wn + ( +__s +, +__c +, +__n +, + +141 + `__bos0 + ( +__s +/  ( +wch_t +)); + +143  + `__wmemt_s + ( +__s +, +__c +, +__n +); + +144 + } +} + +147 +wch_t + * + $__wcsy_chk + ( +wch_t + * +__ri + +__de +, + +148 +__cڡ + +wch_t + * +__ri + +__c +, + +149 +size_t + +__n + +__THROW +; + +150 +wch_t + * + `__REDIRECT_NTH + ( +__wcsy_s +, + +151 ( +wch_t + * +__ri + +__de +, + +152 +__cڡ + +wch_t + * +__ri + +__c +), +wcsy +); + +154 +__ex_ways_le + +wch_t + * + +155 + `__NTH + ( + $wcsy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +)) + +157 i( + `__bos + ( +__de +!( +size_t +) -1) + +158  + `__wcsy_chk + ( +__de +, +__c +, + `__bos + (__de/  ( +wch_t +)); + +159  + `__wcsy_s + ( +__de +, +__c +); + +160 + } +} + +163 +wch_t + * + $__wy_chk + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, + +164 +size_t + +__den + +__THROW +; + +165 +wch_t + * + `__REDIRECT_NTH + ( +__wy_s +, (wch_* +__de +, + +166 +__cڡ + +wch_t + * +__c +), + +167 +wy +); + +169 +__ex_ways_le + +wch_t + * + +170 + `__NTH + ( + $wy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +)) + +172 i( + `__bos + ( +__de +!( +size_t +) -1) + +173  + `__wy_chk + ( +__de +, +__c +, + `__bos + (__de/  ( +wch_t +)); + +174  + `__wy_s + ( +__de +, +__c +); + +175 + } +} + +178 +wch_t + * + $__wcy_chk + ( +wch_t + * +__ri + +__de +, + +179 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +, + +180 +size_t + +__den + +__THROW +; + +181 +wch_t + * + `__REDIRECT_NTH + ( +__wcy_s +, + +182 ( +wch_t + * +__ri + +__de +, + +183 +__cڡ + +wch_t + * +__ri + +__c +, + +184 +size_t + +__n +), +wcy +); + +185 +wch_t + * + `__REDIRECT_NTH + ( +__wcy_chk_wn +, + +186 ( +wch_t + * +__ri + +__de +, + +187 +__cڡ + +wch_t + * +__ri + +__c +, + +188 +size_t + +__n +, size_ +__den +), +__wcy_chk +) + +189 + `__wljr + ("wcsncpy called withength biggerhan size of destination " + +192 +__ex_ways_le + +wch_t + * + +193 + `__NTH + ( + $wcy + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +)) + +195 i( + `__bos + ( +__de +!( +size_t +) -1) + +197 i(! + `__but_cڡt_p + ( +__n +)) + +198  + `__wcy_chk + ( +__de +, +__c +, +__n +, + +199 + `__bos + ( +__de +/  ( +wch_t +)); + +200 i( +__n + > + `__bos + ( +__de +/  ( +wch_t +)) + +201  + `__wcy_chk_wn + ( +__de +, +__c +, +__n +, + +202 + `__bos + ( +__de +/  ( +wch_t +)); + +204  + `__wcy_s + ( +__de +, +__c +, +__n +); + +205 + } +} + +208 +wch_t + * + $__wny_chk + ( +wch_t + * +__ri + +__de +, + +209 +__cڡ + +wch_t + * +__ri + +__c +, +size_t + +__n +, + +210 +size_t + +__den + +__THROW +; + +211 +wch_t + * + `__REDIRECT_NTH + ( +__wny_s +, + +212 ( +wch_t + * +__ri + +__de +, + +213 +__cڡ + +wch_t + * +__ri + +__c +, + +214 +size_t + +__n +), +wny +); + +215 +wch_t + * + `__REDIRECT_NTH + ( +__wny_chk_wn +, + +216 ( +wch_t + * +__ri + +__de +, + +217 +__cڡ + +wch_t + * +__ri + +__c +, + +218 +size_t + +__n +, size_ +__den +), +__wny_chk +) + +219 + `__wljr + ("wcpncpy called withength biggerhan size of destination " + +222 +__ex_ways_le + +wch_t + * + +223 + `__NTH + ( + $wny + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +)) + +225 i( + `__bos + ( +__de +!( +size_t +) -1) + +227 i(! + `__but_cڡt_p + ( +__n +)) + +228  + `__wny_chk + ( +__de +, +__c +, +__n +, + +229 + `__bos + ( +__de +/  ( +wch_t +)); + +230 i( +__n + > + `__bos + ( +__de +/  ( +wch_t +)) + +231  + `__wny_chk_wn + ( +__de +, +__c +, +__n +, + +232 + `__bos + ( +__de +/  ( +wch_t +)); + +234  + `__wny_s + ( +__de +, +__c +, +__n +); + +235 + } +} + +238 +wch_t + * + $__wcst_chk + ( +wch_t + * +__ri + +__de +, + +239 +__cڡ + +wch_t + * +__ri + +__c +, + +240 +size_t + +__den + +__THROW +; + +241 +wch_t + * + `__REDIRECT_NTH + ( +__wcst_s +, + +242 ( +wch_t + * +__ri + +__de +, + +243 +__cڡ + +wch_t + * +__ri + +__c +), +wcst +); + +245 +__ex_ways_le + +wch_t + * + +246 + `__NTH + ( + $wcst + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +)) + +248 i( + `__bos + ( +__de +!( +size_t +) -1) + +249  + `__wcst_chk + ( +__de +, +__c +, + `__bos + (__de/  ( +wch_t +)); + +250  + `__wcst_s + ( +__de +, +__c +); + +251 + } +} + +254 +wch_t + * + $__wct_chk + ( +wch_t + * +__ri + +__de +, + +255 +__cڡ + +wch_t + * +__ri + +__c +, + +256 +size_t + +__n +, size_ +__den + +__THROW +; + +257 +wch_t + * + `__REDIRECT_NTH + ( +__wct_s +, + +258 ( +wch_t + * +__ri + +__de +, + +259 +__cڡ + +wch_t + * +__ri + +__c +, + +260 +size_t + +__n +), +wct +); + +262 +__ex_ways_le + +wch_t + * + +263 + `__NTH + ( + $wct + ( +wch_t + * +__de +, +__cڡ + wch_* +__c +, +size_t + +__n +)) + +265 i( + `__bos + ( +__de +!( +size_t +) -1) + +266  + `__wct_chk + ( +__de +, +__c +, +__n +, + +267 + `__bos + ( +__de +/  ( +wch_t +)); + +268  + `__wct_s + ( +__de +, +__c +, +__n +); + +269 + } +} + +272  + $__swtf_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +273  +__ag +, +size_t + +__s_n +, + +274 +__cڡ + +wch_t + * +__ri + +__fm +, ...) + +275 +__THROW + ; + +277  + `__REDIRECT_NTH_LDBL + ( +__swtf_s +, + +278 ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +279 +__cڡ + +wch_t + * +__ri + +__fmt +, ...), + +280 +swtf +); + +282 #ifde +__va_g_ck + + +283 +__ex_ways_le +  + +284 + `__NTH + ( + $swtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +285 +__cڡ + +wch_t + * +__ri + +__fmt +, ...)) + +287 i( + `__bos + ( +__s +!( +size_t +-1 || +__USE_FORTIFY_LEVEL + > 1) + +288  + `__swtf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +289 + `__bos + ( +__s +/  ( +wch_t +), + +290 +__fmt +, + `__va_g_ck + ()); + +291  + `__swtf_s + ( +__s +, +__n +, +__fmt +, + `__va_g_ck + ()); + +292 + } +} + +293 #i! +defed + +__lulus + + +295  + #swtf +( +s +, +n +, ...) \ + +296 ( + `__bos + ( +s +!( +size_t +-1 || +__USE_FORTIFY_LEVEL + > 1 \ + +297 ? + `__swtf_chk + ( +s +, +n +, +__USE_FORTIFY_LEVEL + - 1, \ + +298 + `__bos + ( +s +/  ( +wch_t +), +__VA_ARGS__ +) \ + +299 : + `swtf + ( +s +, +n +, +__VA_ARGS__ +)) + + ) + +302  + $__vswtf_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +303  +__ag +, +size_t + +__s_n +, + +304 +__cڡ + +wch_t + * +__ri + +__fm +, + +305 +__gnuc_va_li + +__g +) + +306 +__THROW + ; + +308  + `__REDIRECT_NTH_LDBL + ( +__vswtf_s +, + +309 ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +310 +__cڡ + +wch_t + * +__ri + +__fmt +, + +311 +__gnuc_va_li + +__ +), +vswtf +); + +313 +__ex_ways_le +  + +314 + `__NTH + ( + $vswtf + ( +wch_t + * +__ri + +__s +, +size_t + +__n +, + +315 +__cڡ + +wch_t + * +__ri + +__fmt +, +__gnuc_va_li + +__ +)) + +317 i( + `__bos + ( +__s +!( +size_t +-1 || +__USE_FORTIFY_LEVEL + > 1) + +318  + `__vswtf_chk + ( +__s +, +__n +, +__USE_FORTIFY_LEVEL + - 1, + +319 + `__bos + ( +__s +/  ( +wch_t +), +__fmt +, +__ +); + +320  + `__vswtf_s + ( +__s +, +__n +, +__fmt +, +__ +); + +321 + } +} + +324 #i +__USE_FORTIFY_LEVEL + > 1 + +326  +__fwtf_chk + ( +__FILE + * +__ri + +__am +,  +__ag +, + +327 +__cڡ + +wch_t + * +__ri + +__fm +, ...); + +328  +__wtf_chk + ( +__ag +, +__cڡ + +wch_t + * +__ri + +__fm +, + +330  +__vfwtf_chk + ( +__FILE + * +__ri + +__am +,  +__ag +, + +331 +__cڡ + +wch_t + * +__ri + +__fm +, + +332 +__gnuc_va_li + +__ +); + +333  +__vwtf_chk + ( +__ag +, +__cڡ + +wch_t + * +__ri + +__fm +, + +334 +__gnuc_va_li + +__ +); + +336 #ifde +__va_g_ck + + +337 +__ex_ways_le +  + +338 + $wtf + ( +__cڡ + +wch_t + * +__ri + +__fmt +, ...) + +340  + `__wtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + `__va_g_ck + ()); + +341 + } +} + +343 +__ex_ways_le +  + +344 + $fwtf + ( +__FILE + * +__ri + +__am +, +__cڡ + +wch_t + *__ri +__fmt +, ...) + +346  + `__fwtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, + +347 + `__va_g_ck + ()); + +348 + } +} + +349 #i! +defed + +__lulus + + +350  + #wtf +(...) \ + +351 + `__wtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +352  + #fwtf +( +am +, ...) \ + +353 + `__fwtf_chk + ( +am +, +__USE_FORTIFY_LEVEL + - 1, +__VA_ARGS__ +) + + ) + +356 +__ex_ways_le +  + +357 + $vwtf + ( +__cڡ + +wch_t + * +__ri + +__fmt +, +__gnuc_va_li + +__ +) + +359  + `__vwtf_chk + ( +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +360 + } +} + +362 +__ex_ways_le +  + +363 + $vfwtf + ( +__FILE + * +__ri + +__am +, + +364 +__cڡ + +wch_t + * +__ri + +__fmt +, +__gnuc_va_li + +__ +) + +366  + `__vfwtf_chk + ( +__am +, +__USE_FORTIFY_LEVEL + - 1, +__fmt +, +__ +); + +367 + } +} + +371 +wch_t + * + $__fgws_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__size +,  +__n +, + +372 +__FILE + * +__ri + +__am + +__wur +; + +373 +wch_t + * + `__REDIRECT + ( +__fgws_s +, + +374 ( +wch_t + * +__ri + +__s +,  +__n +, + +375 +__FILE + * +__ri + +__am +), +fgws + +__wur +; + +376 +wch_t + * + `__REDIRECT + ( +__fgws_chk_wn +, + +377 ( +wch_t + * +__ri + +__s +, +size_t + +__size +,  +__n +, + +378 +__FILE + * +__ri + +__am +), +__fgws_chk +) + +379 +__wur + + `__wljr + ("fgetws called with bigger sizehanength " + +382 +__ex_ways_le + +__wur + +wch_t + * + +383 + $fgws + ( +wch_t + * +__ri + +__s +,  +__n +, +__FILE + *__ri +__am +) + +385 i( + `__bos + ( +__s +!( +size_t +) -1) + +387 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +388  + `__fgws_chk + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +389 +__n +, +__am +); + +391 i(( +size_t + +__n + > + `__bos + ( +__s +/  ( +wch_t +)) + +392  + `__fgws_chk_wn + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +393 +__n +, +__am +); + +395  + `__fgws_s + ( +__s +, +__n +, +__am +); + +396 + } +} + +398 #ifde +__USE_GNU + + +399 +wch_t + * + $__fgws_uocked_chk + ( +wch_t + * +__ri + +__s +, +size_t + +__size +, + +400  +__n +, +__FILE + * +__ri + +__am +) + +401 +__wur +; + +402 +wch_t + * + `__REDIRECT + ( +__fgws_uocked_s +, + +403 ( +wch_t + * +__ri + +__s +,  +__n +, + +404 +__FILE + * +__ri + +__am +), +fgws_uocked +) + +405 +__wur +; + +406 +wch_t + * + `__REDIRECT + ( +__fgws_uocked_chk_wn +, + +407 ( +wch_t + * +__ri + +__s +, +size_t + +__size +,  +__n +, + +408 +__FILE + * +__ri + +__am +), + +409 +__fgws_uocked_chk +) + +410 +__wur + + `__wljr + ("fgetws_unlocked called with bigger sizehanength " + +413 +__ex_ways_le + +__wur + +wch_t + * + +414 + $fgws_uocked + ( +wch_t + * +__ri + +__s +,  +__n +, +__FILE + *__ri +__am +) + +416 i( + `__bos + ( +__s +!( +size_t +) -1) + +418 i(! + `__but_cڡt_p + ( +__n +) || __n <= 0) + +419  + `__fgws_uocked_chk + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +420 +__n +, +__am +); + +422 i(( +size_t + +__n + > + `__bos + ( +__s +/  ( +wch_t +)) + +423  + `__fgws_uocked_chk_wn + ( +__s +, + `__bos + (__s/  ( +wch_t +), + +424 +__n +, +__am +); + +426  + `__fgws_uocked_s + ( +__s +, +__n +, +__am +); + +427 + } +} + +431 +size_t + + $__wtomb_chk + (* +__s +, +wch_t + +__wch +, +mbe_t + * +__p +, + +432 +size_t + +__bu + +__THROW + +__wur +; + +433 +size_t + + `__REDIRECT_NTH + ( +__wtomb_s +, + +434 (* +__ri + +__s +, +wch_t + +__wch +, + +435 +mbe_t + * +__ri + +__ps +), +wtomb + +__wur +; + +437 +__ex_ways_le + +__wur + +size_t + + +438 + `__NTH + ( + $wtomb + (* +__s +, +wch_t + +__wch +, +mbe_t + * +__ps +)) + +443  + #__WCHAR_MB_LEN_MAX + 16 + + ) + +444 #i +defed + +MB_LEN_MAX + && MB_LEN_MAX ! +__WCHAR_MB_LEN_MAX + + +447 i( + `__bos + ( +__s +!( +size_t +-1 && +__WCHAR_MB_LEN_MAX + > __bos (__s)) + +448  + `__wtomb_chk + ( +__s +, +__wch +, +__ps +, + `__bos + (__s)); + +449  + `__wtomb_s + ( +__s +, +__wch +, +__ps +); + +450 + } +} + +453 +size_t + + $__mbtowcs_chk + ( +wch_t + * +__ri + +__d +, + +454 +__cڡ + ** +__ri + +__c +, + +455 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +456 +size_t + +__dn + +__THROW +; + +457 +size_t + + `__REDIRECT_NTH + ( +__mbtowcs_s +, + +458 ( +wch_t + * +__ri + +__d +, + +459 +__cڡ + ** +__ri + +__c +, + +460 +size_t + +__n +, +mbe_t + * +__ri + +__ps +), + +461 +mbtowcs +); + +462 +size_t + + `__REDIRECT_NTH + ( +__mbtowcs_chk_wn +, + +463 ( +wch_t + * +__ri + +__d +, + +464 +__cڡ + ** +__ri + +__c +, + +465 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +466 +size_t + +__dn +), +__mbtowcs_chk +) + +467 + `__wljr + ("mbsrtowcs called with dst buffer smallerhanen " + +470 +__ex_ways_le + +size_t + + +471 + `__NTH + ( + $mbtowcs + ( +wch_t + * +__ri + +__d +, +__cڡ + **__ri +__c +, + +472 +size_t + +__n +, +mbe_t + * +__ri + +__ps +)) + +474 i( + `__bos + ( +__d +!( +size_t +) -1) + +476 i(! + `__but_cڡt_p + ( +__n +)) + +477  + `__mbtowcs_chk + ( +__d +, +__c +, +__n +, +__ps +, + +478 + `__bos + ( +__d +/  ( +wch_t +)); + +480 i( +__n + > + `__bos + ( +__d +/  ( +wch_t +)) + +481  + `__mbtowcs_chk_wn + ( +__d +, +__c +, +__n +, +__ps +, + +482 + `__bos + ( +__d +/  ( +wch_t +)); + +484  + `__mbtowcs_s + ( +__d +, +__c +, +__n +, +__ps +); + +485 + } +} + +488 +size_t + + $__wctombs_chk + (* +__ri + +__d +, + +489 +__cڡ + +wch_t + ** +__ri + +__c +, + +490 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +491 +size_t + +__dn + +__THROW +; + +492 +size_t + + `__REDIRECT_NTH + ( +__wctombs_s +, + +493 (* +__ri + +__d +, + +494 +__cڡ + +wch_t + ** +__ri + +__c +, + +495 +size_t + +__n +, +mbe_t + * +__ri + +__ps +), + +496 +wctombs +); + +497 +size_t + + `__REDIRECT_NTH + ( +__wctombs_chk_wn +, + +498 (* +__ri + +__d +, + +499 +__cڡ + +wch_t + ** +__ri + +__c +, + +500 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +501 +size_t + +__dn +), +__wctombs_chk +) + +502 + `__wljr + ("wcsrtombs called with dst buffer smallerhanen"); + +504 +__ex_ways_le + +size_t + + +505 + `__NTH + ( + $wctombs + (* +__ri + +__d +, +__cڡ + +wch_t + **__ri +__c +, + +506 +size_t + +__n +, +mbe_t + * +__ri + +__ps +)) + +508 i( + `__bos + ( +__d +!( +size_t +) -1) + +510 i(! + `__but_cڡt_p + ( +__n +)) + +511  + `__wctombs_chk + ( +__d +, +__c +, +__n +, +__ps +, + `__bos + (__dst)); + +513 i( +__n + > + `__bos + ( +__d +)) + +514  + `__wctombs_chk_wn + ( +__d +, +__c +, +__n +, +__ps +, + `__bos + (__dst)); + +516  + `__wctombs_s + ( +__d +, +__c +, +__n +, +__ps +); + +517 + } +} + +520 #ifde +__USE_GNU + + +521 +size_t + + $__mbowcs_chk + ( +wch_t + * +__ri + +__d +, + +522 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +523 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +524 +size_t + +__dn + +__THROW +; + +525 +size_t + + `__REDIRECT_NTH + ( +__mbowcs_s +, + +526 ( +wch_t + * +__ri + +__d +, + +527 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +528 +size_t + +__n +, +mbe_t + * +__ri + +__ps +), + +529 +mbowcs +); + +530 +size_t + + `__REDIRECT_NTH + ( +__mbowcs_chk_wn +, + +531 ( +wch_t + * +__ri + +__d +, + +532 +__cڡ + ** +__ri + +__c +, +size_t + +__nmc +, + +533 +size_t + +__n +, +mbe_t + * +__ri + +__ps +, + +534 +size_t + +__dn +), +__mbowcs_chk +) + +535 + `__wljr + ("mbsnrtowcs called with dst buffer smallerhanen " + +538 +__ex_ways_le + +size_t + + +539 + `__NTH + ( + $mbowcs + ( +wch_t + * +__ri + +__d +, +__cڡ + **__ri +__c +, + +540 +size_t + +__nmc +, size_ +__n +, +mbe_t + * +__ri + +__ps +)) + +542 i( + `__bos + ( +__d +!( +size_t +) -1) + +544 i(! + `__but_cڡt_p + ( +__n +)) + +545  + `__mbowcs_chk + ( +__d +, +__c +, +__nmc +, +__n +, +__ps +, + +546 + `__bos + ( +__d +/  ( +wch_t +)); + +548 i( +__n + > + `__bos + ( +__d +/  ( +wch_t +)) + +549  + `__mbowcs_chk_wn + ( +__d +, +__c +, +__nmc +, +__n +, +__ps +, + +550 + `__bos + ( +__d +/  ( +wch_t +)); + +552  + `__mbowcs_s + ( +__d +, +__c +, +__nmc +, +__n +, +__ps +); + +553 + } +} + +556 +size_t + + $__wcombs_chk + (* +__ri + +__d +, + +557 +__cڡ + +wch_t + ** +__ri + +__c +, + +558 +size_t + +__nwc +, size_ +__n +, + +559 +mbe_t + * +__ri + +__ps +, +size_t + +__dn +) + +560 +__THROW +; + +561 +size_t + + `__REDIRECT_NTH + ( +__wcombs_s +, + +562 (* +__ri + +__d +, + +563 +__cڡ + +wch_t + ** +__ri + +__c +, + +564 +size_t + +__nwc +, size_ +__n +, + +565 +mbe_t + * +__ri + +__ps +), +wcombs +); + +566 +size_t + + `__REDIRECT_NTH + ( +__wcombs_chk_wn +, + +567 (* +__ri + +__d +, + +568 +__cڡ + +wch_t + ** +__ri + +__c +, + +569 +size_t + +__nwc +, size_ +__n +, + +570 +mbe_t + * +__ri + +__ps +, + +571 +size_t + +__dn +), +__wcombs_chk +) + +572 + `__wljr + ("wcsnrtombs called with dst buffer smallerhanen"); + +574 +__ex_ways_le + +size_t + + +575 + `__NTH + ( + $wcombs + (* +__ri + +__d +, +__cڡ + +wch_t + **__ri +__c +, + +576 +size_t + +__nwc +, size_ +__n +, +mbe_t + * +__ri + +__ps +)) + +578 i( + `__bos + ( +__d +!( +size_t +) -1) + +580 i(! + `__but_cڡt_p + ( +__n +)) + +581  + `__wcombs_chk + ( +__d +, +__c +, +__nwc +, +__n +, +__ps +, + +582 + `__bos + ( +__d +)); + +584 i( +__n + > + `__bos + ( +__d +)) + +585  + `__wcombs_chk_wn + ( +__d +, +__c +, +__nwc +, +__n +, +__ps +, + +586 + `__bos + ( +__d +)); + +588  + `__wcombs_s + ( +__d +, +__c +, +__nwc +, +__n +, +__ps +); + +589 + } +} + + @/usr/include/errno.h + +23 #idef +_ERRNO_H + + +27 #idef +__ed_Emh + + +28  + #_ERRNO_H + 1 + + ) + +29  + ~ + +32 + g__BEGIN_DECLS + + +36  + ~ + +37 #unde +__ed_Emh + + +39 #ifdef +_ERRNO_H + + +46 #idef +o + + +47  +o +; + +50 #ifde +__USE_GNU + + +55 * +ogm_voti_me +, * +ogm_voti_sht_me +; + +59 + g__END_DECLS + + +67 #i +defed + +__USE_GNU + || defed +__ed_r_t + + +68 #ide +__r_t_defed + + +69  + tr_t +; + +70  + #__r_t_defed + 1 + + ) + +72 #unde +__ed_r_t + + + @/usr/include/gnu/option-groups.h + +10 #ide +__GNU_OPTION_GROUPS_H + + +11  + #__GNU_OPTION_GROUPS_H + + + ) + +13  + #__OPTION_EGLIBC_ADVANCED_INET6 + 1 + + ) + +14  + #__OPTION_EGLIBC_BACKTRACE + 1 + + ) + +15  + #__OPTION_EGLIBC_BIG_MACROS + 1 + + ) + +16  + #__OPTION_EGLIBC_BSD + 1 + + ) + +17  + #__OPTION_EGLIBC_CATGETS + 1 + + ) + +18  + #__OPTION_EGLIBC_CHARSETS + 1 + + ) + +19  + #__OPTION_EGLIBC_CXX_TESTS + 1 + + ) + +20  + #__OPTION_EGLIBC_DB_ALIASES + 1 + + ) + +21  + #__OPTION_EGLIBC_ENVZ + 1 + + ) + +22  + #__OPTION_EGLIBC_FCVT + 1 + + ) + +23  + #__OPTION_EGLIBC_FMTMSG + 1 + + ) + +24  + #__OPTION_EGLIBC_FSTAB + 1 + + ) + +25  + #__OPTION_EGLIBC_FTRAVERSE + 1 + + ) + +26  + #__OPTION_EGLIBC_GETLOGIN + 1 + + ) + +27  + #__OPTION_EGLIBC_INET + 1 + + ) + +28  + #__OPTION_EGLIBC_LIBM + 1 + + ) + +29  + #__OPTION_EGLIBC_LOCALES + 1 + + ) + +30  + #__OPTION_EGLIBC_LOCALE_CODE + 1 + + ) + +31  + #__OPTION_EGLIBC_MEMUSAGE + 1 + + ) + +32  + #__OPTION_EGLIBC_NIS + 1 + + ) + +33  + #__OPTION_EGLIBC_NSSWITCH + 1 + + ) + +34  + #__OPTION_EGLIBC_RCMD + 1 + + ) + +35  + #__OPTION_EGLIBC_SPAWN + 1 + + ) + +36  + #__OPTION_EGLIBC_STREAMS + 1 + + ) + +37  + #__OPTION_EGLIBC_SUNRPC + 1 + + ) + +38  + #__OPTION_EGLIBC_UTMP + 1 + + ) + +39  + #__OPTION_EGLIBC_UTMPX + 1 + + ) + +40  + #__OPTION_EGLIBC_WORDEXP + 1 + + ) + +41  + #__OPTION_POSIX_C_LANG_WIDE_CHAR + 1 + + ) + +42  + #__OPTION_POSIX_REGEXP + 1 + + ) + +43  + #__OPTION_POSIX_REGEXP_GLIBC + 1 + + ) + +44  + #__OPTION_POSIX_WIDE_CHAR_DEVICE_IO + 1 + + ) + + @/usr/include/pthread.h + +20 #ide +_PTHREAD_H + + +21  + #_PTHREAD_H + 1 + + ) + +23  + ~ + +24  + ~ + +25  + ~ + +26  + ~ + +28  + #__ed_sigt_t + + + ) + +29  + ~ + +30  + ~ + +31  + ~ + +32  + ~ + +38 + mPTHREAD_CREATE_JOINABLE +, + +39  + #PTHREAD_CREATE_JOINABLE + +PTHREAD_CREATE_JOINABLE + + + ) + +40 + mPTHREAD_CREATE_DETACHED + + +41  + #PTHREAD_CREATE_DETACHED + +PTHREAD_CREATE_DETACHED + + + ) + +48 + mPTHREAD_MUTEX_TIMED_NP +, + +49 + mPTHREAD_MUTEX_RECURSIVE_NP +, + +50 + mPTHREAD_MUTEX_ERRORCHECK_NP +, + +51 + mPTHREAD_MUTEX_ADAPTIVE_NP + + +52 #ifde +__USE_UNIX98 + + +54 + mPTHREAD_MUTEX_NORMAL + = +PTHREAD_MUTEX_TIMED_NP +, + +55 + mPTHREAD_MUTEX_RECURSIVE + = +PTHREAD_MUTEX_RECURSIVE_NP +, + +56 + mPTHREAD_MUTEX_ERRORCHECK + = +PTHREAD_MUTEX_ERRORCHECK_NP +, + +57 + mPTHREAD_MUTEX_DEFAULT + = +PTHREAD_MUTEX_NORMAL + + +59 #ifde +__USE_GNU + + +61 , + mPTHREAD_MUTEX_FAST_NP + = +PTHREAD_MUTEX_TIMED_NP + + +66 #ifde +__USE_XOPEN2K + + +70 + mPTHREAD_MUTEX_STALLED +, + +71 + mPTHREAD_MUTEX_STALLED_NP + = +PTHREAD_MUTEX_STALLED +, + +72 + mPTHREAD_MUTEX_ROBUST +, + +73 + mPTHREAD_MUTEX_ROBUST_NP + = +PTHREAD_MUTEX_ROBUST + + +78 #ifde +__USE_UNIX98 + + +82 + mPTHREAD_PRIO_NONE +, + +83 + mPTHREAD_PRIO_INHERIT +, + +84 + mPTHREAD_PRIO_PROTECT + + +90 #i +__WORDSIZE + == 64 + +91  + #PTHREAD_MUTEX_INITIALIZER + \ + +92 { { 0, 0, 0, 0, 0, 0, { 0, 0 } } } + + ) + +93 #ifde +__USE_GNU + + +94  + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +95 { { 0, 0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, 0, { 0, 0 } } } + + ) + +96  + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +97 { { 0, 0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, 0, { 0, 0 } } } + + ) + +98  + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +99 { { 0, 0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, 0, { 0, 0 } } } + + ) + +102  + #PTHREAD_MUTEX_INITIALIZER + \ + +103 { { 0, 0, 0, 0, 0, { 0 } } } + + ) + +104 #ifde +__USE_GNU + + +105  + #PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + \ + +106 { { 0, 0, 0, +PTHREAD_MUTEX_RECURSIVE_NP +, 0, { 0 } } } + + ) + +107  + #PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP + \ + +108 { { 0, 0, 0, +PTHREAD_MUTEX_ERRORCHECK_NP +, 0, { 0 } } } + + ) + +109  + #PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP + \ + +110 { { 0, 0, 0, +PTHREAD_MUTEX_ADAPTIVE_NP +, 0, { 0 } } } + + ) + +116 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +119 + mPTHREAD_RWLOCK_PREFER_READER_NP +, + +120 + mPTHREAD_RWLOCK_PREFER_WRITER_NP +, + +121 + mPTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, + +122 + mPTHREAD_RWLOCK_DEFAULT_NP + = +PTHREAD_RWLOCK_PREFER_READER_NP + + +126  + #PTHREAD_RWLOCK_INITIALIZER + \ + +127 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } + + ) + +128 #ifde +__USE_GNU + + +129 #i +__WORDSIZE + == 64 + +130  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +132 +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP + } } + + ) + +134 #i +__BYTE_ORDER + = +__LITTLE_ENDIAN + + +135  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +136 { { 0, 0, 0, 0, 0, 0, +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +, \ + +137 0, 0, 0, 0 } } + + ) + +139  + #PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP + \ + +140 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, +PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP +,\ + +141 0 } } + + ) + +151 + mPTHREAD_INHERIT_SCHED +, + +152  + #PTHREAD_INHERIT_SCHED + +PTHREAD_INHERIT_SCHED + + + ) + +153 + mPTHREAD_EXPLICIT_SCHED + + +154  + #PTHREAD_EXPLICIT_SCHED + +PTHREAD_EXPLICIT_SCHED + + + ) + +161 + mPTHREAD_SCOPE_SYSTEM +, + +162  + #PTHREAD_SCOPE_SYSTEM + +PTHREAD_SCOPE_SYSTEM + + + ) + +163 + mPTHREAD_SCOPE_PROCESS + + +164  + #PTHREAD_SCOPE_PROCESS + +PTHREAD_SCOPE_PROCESS + + + ) + +171 + mPTHREAD_PROCESS_PRIVATE +, + +172  + #PTHREAD_PROCESS_PRIVATE + +PTHREAD_PROCESS_PRIVATE + + + ) + +173 + mPTHREAD_PROCESS_SHARED + + +174  + #PTHREAD_PROCESS_SHARED + +PTHREAD_PROCESS_SHARED + + + ) + +180  + #PTHREAD_COND_INITIALIZER + { { 0, 0, 0, 0, 0, (*0, 0, 0 } } + + ) + +184  + s_had_nup_bufr + + +186 (* + m__route +) (*); + +187 * + m__g +; + +188  + m__ny +; + +189  +_had_nup_bufr + * + m__ev +; + +195 + mPTHREAD_CANCEL_ENABLE +, + +196  + #PTHREAD_CANCEL_ENABLE + +PTHREAD_CANCEL_ENABLE + + + ) + +197 + mPTHREAD_CANCEL_DISABLE + + +198  + #PTHREAD_CANCEL_DISABLE + +PTHREAD_CANCEL_DISABLE + + + ) + +202 + mPTHREAD_CANCEL_DEFERRED +, + +203  + #PTHREAD_CANCEL_DEFERRED + +PTHREAD_CANCEL_DEFERRED + + + ) + +204 + mPTHREAD_CANCEL_ASYNCHRONOUS + + +205  + #PTHREAD_CANCEL_ASYNCHRONOUS + +PTHREAD_CANCEL_ASYNCHRONOUS + + + ) + +207  + #PTHREAD_CANCELED + ((*-1) + + ) + +211  + #PTHREAD_ONCE_INIT + 0 + + ) + +214 #ifde +__USE_XOPEN2K + + +218  + #PTHREAD_BARRIER_SERIAL_THREAD + -1 + + ) + +222 +__BEGIN_DECLS + + +227  +had_ + ( +had_t + * +__ri + +__wthad +, + +228 +__cڡ + +had__t + * +__ri + +__ +, + +229 *(* +__t_route +) (*), + +230 * +__ri + +__g + +__THROW + +__nnu + ((1, 3)); + +236  + $had_ex + (* +__tv + + `__ibu__ + (( +__nܑu__ +)); + +244  + `had_jo + ( +had_t + +__th +, ** +__thad_tu +); + +246 #ifde +__USE_GNU + + +249  + $had_yjo_ + ( +had_t + +__th +, ** +__thad_tu + +__THROW +; + +257  + `had_timedjo_ + ( +had_t + +__th +, ** +__thad_tu +, + +258 +__cڡ +  +timeec + * +__abime +); + +265  + $had_dach + ( +had_t + +__th + +__THROW +; + +269 +had_t + + $had_lf + ( +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +272  + $had_equ + ( +had_t + +__thad1 +,thad_ +__thad2 + +__THROW +; + +280  + $had__ + ( +had__t + * +__ + +__THROW + + `__nnu + ((1)); + +283  + $had__deroy + ( +had__t + * +__ +) + +284 +__THROW + + `__nnu + ((1)); + +287  + $had__gdache + ( +__cڡ + +had__t + * +__ +, + +288 * +__dache +) + +289 +__THROW + + `__nnu + ((1, 2)); + +292  + $had__tdache + ( +had__t + * +__ +, + +293  +__dache +) + +294 +__THROW + + `__nnu + ((1)); + +298  + $had__ggudsize + ( +__cڡ + +had__t + * +__ +, + +299 +size_t + * +__gudsize +) + +300 +__THROW + + `__nnu + ((1, 2)); + +303  + $had__tgudsize + ( +had__t + * +__ +, + +304 +size_t + +__gudsize +) + +305 +__THROW + + `__nnu + ((1)); + +309  + $had__gschedm + ( +__cڡ + +had__t + * +__ri + + +310 +__ +, + +311  +sched_m + * +__ri + +__m +) + +312 +__THROW + + `__nnu + ((1, 2)); + +315  + $had__tschedm + ( +had__t + * +__ri + +__ +, + +316 +__cڡ +  +sched_m + * +__ri + + +317 +__m + +__THROW + + `__nnu + ((1, 2)); + +320  + $had__gschedpicy + ( +__cڡ + +had__t + * +__ri + + +321 +__ +, * +__ri + +__picy +) + +322 +__THROW + + `__nnu + ((1, 2)); + +325  + $had__tschedpicy + ( +had__t + * +__ +,  +__picy +) + +326 +__THROW + + `__nnu + ((1)); + +329  + $had__ghsched + ( +__cڡ + +had__t + * +__ri + + +330 +__ +, * +__ri + +__h +) + +331 +__THROW + + `__nnu + ((1, 2)); + +334  + $had__thsched + ( +had__t + * +__ +, + +335  +__h +) + +336 +__THROW + + `__nnu + ((1)); + +340  + $had__gsce + ( +__cڡ + +had__t + * +__ri + +__ +, + +341 * +__ri + +__sce +) + +342 +__THROW + + `__nnu + ((1, 2)); + +345  + $had__tsce + ( +had__t + * +__ +,  +__sce +) + +346 +__THROW + + `__nnu + ((1)); + +349  + $had__gackaddr + ( +__cڡ + +had__t + * +__ri + + +350 +__ +, ** +__ri + +__ackaddr +) + +351 +__THROW + + `__nnu + ((1, 2) +__ibu_dd__ +; + +357  + $had__tackaddr + ( +had__t + * +__ +, + +358 * +__ackaddr +) + +359 +__THROW + + `__nnu + ((1) +__ibu_dd__ +; + +362  + $had__gacksize + ( +__cڡ + +had__t + * +__ri + + +363 +__ +, +size_t + * +__ri + +__acksize +) + +364 +__THROW + + `__nnu + ((1, 2)); + +369  + $had__tacksize + ( +had__t + * +__ +, + +370 +size_t + +__acksize +) + +371 +__THROW + + `__nnu + ((1)); + +373 #ifde +__USE_XOPEN2K + + +375  + $had__gack + ( +__cڡ + +had__t + * +__ri + +__ +, + +376 ** +__ri + +__ackaddr +, + +377 +size_t + * +__ri + +__acksize +) + +378 +__THROW + + `__nnu + ((1, 2, 3)); + +383  + $had__tack + ( +had__t + * +__ +, * +__ackaddr +, + +384 +size_t + +__acksize + +__THROW + + `__nnu + ((1)); + +387 #ifde +__USE_GNU + + +390  + $had__ffy_ + ( +had__t + * +__ +, + +391 +size_t + +__utsize +, + +392 +__cڡ + +u_t_t + * +__ut +) + +393 +__THROW + + `__nnu + ((1, 3)); + +397  + $had__gaffy_ + ( +__cڡ + +had__t + * +__ +, + +398 +size_t + +__utsize +, + +399 +u_t_t + * +__ut +) + +400 +__THROW + + `__nnu + ((1, 3)); + +406  + $had_g_ + ( +had_t + +__th +, +had__t + * +__ +) + +407 +__THROW + + `__nnu + ((2)); + +415  + $had_tschedm + ( +had_t + +__rg_thad +,  +__picy +, + +416 +__cڡ +  +sched_m + * +__m +) + +417 +__THROW + + `__nnu + ((3)); + +420  + $had_gschedm + ( +had_t + +__rg_thad +, + +421 * +__ri + +__picy +, + +422  +sched_m + * +__ri + +__m +) + +423 +__THROW + + `__nnu + ((2, 3)); + +426  + $had_tschedio + ( +had_t + +__rg_thad +,  +__io +) + +427 +__THROW +; + +430 #ifde +__USE_UNIX98 + + +432  + $had_gccucy + ( +__THROW +; + +435  + $had_tccucy + ( +__v + +__THROW +; + +438 #ifde +__USE_GNU + + +443  + $had_yld + ( +__THROW +; + +448  + $had_ffy_ + ( +had_t + +__th +, +size_t + +__utsize +, + +449 +__cڡ + +u_t_t + * +__ut +) + +450 +__THROW + + `__nnu + ((3)); + +453  + $had_gaffy_ + ( +had_t + +__th +, +size_t + +__utsize +, + +454 +u_t_t + * +__ut +) + +455 +__THROW + + `__nnu + ((3)); + +468  + `had_ + ( +had__t + * +___cڌ +, + +469 (* +___route +() + `__nnu + ((1, 2)); + +480  + `had_tnle + ( +__e +, * +__de +); + +484  + `had_tny + ( +__ty +, * +__dty +); + +487  + `had_nl + ( +had_t + +__th +); + +492  + `had_nl + (); + +501 +__jmp_buf + +__nl_jmp_buf +; + +502  +__mask_was_ved +; + +503 } +__nl_jmp_buf +[1]; + +504 * +__d +[4]; + +505 } + t__had_unwd_buf_t + + t__ibu__ + (( + t__igd__ +)); + +508 #ide +__nup_f_ibu + + +509  + #__nup_f_ibu + + + ) + +514  + s__had_nup_ame + + +516 (* +__nl_route +) (*); + +517 * +__nl_g +; + +518  +__do_ +; + +519  +__nl_ty +; + +522 #i +defed + +__GNUC__ + && defed +__EXCEPTIONS + + +523 #ifde +__lulus + + +525 as + c__had_nup_ass + + +527 (* +__nl_route +) (*); + +528 * +__nl_g +; + +529  +__do_ +; + +530  +__nl_ty +; + +532 +public +: + +533 + `__had_nup_ass + ((* +__f +(*), * +__g +) + +534 : + `__nl_route + ( +__f +), + `__nl_g + ( +__g +), + $__do_ + (1) { } + +535 ~ + $__had_nup_ass + ({ i( +__do_ + + `__nl_route + ( +__nl_g +); + } +} + +536  + $__tdo + ( +__wv +{ +__do_ + = __wv; + } +} + +537  + $__der + ({ + `had_tny + ( +PTHREAD_CANCEL_DEFERRED +, + +538 & +__nl_ty +); + } +} + +539  + $__e + (cڡ { + `had_tny + ( +__nl_ty +, 0); + } +} + +549  + #had_nup_push +( +route +, +g +) \ + +551 +__had_nup_ass + + `__ame + ( +route +, +g +) + + ) + +555  + #had_nup_p +( +execu +) \ + +556 +__ame +. + `__tdo + ( +execu +); \ + +557 } 0) + + ) + +559 #ifde +__USE_GNU + + +563  + #had_nup_push_der_ +( +route +, +g +) \ + +565 +__had_nup_ass + + `__ame + ( +route +, +g +); \ + +566 +__ame +. + `__der + () + + ) + +571  + #had_nup_p_e_ +( +execu +) \ + +572 +__ame +. + `__e + (); \ + +573 +__ame +. + `__tdo + ( +execu +); \ + +574 } 0) + + ) + +581 +__ex_le +  + +582 + $__had_nup_route + ( +__had_nup_ame + * +__ame +) + +584 i( +__ame +-> +__do_ +) + +585 +__ame +-> + `__nl_route + (__ame-> +__nl_g +); + +586 + } +} + +595  + #had_nup_push +( +route +, +g +) \ + +597  +__had_nup_ame + +__ame + \ + +598 + `__ibu__ + (( + `__nup__ + ( +__had_nup_route +))) \ + +599 { . +__nl_route + = ( +route +), . +__nl_g + = ( +g +), \ + +600 . +__do_ + = 1 }; + + ) + +604  + #had_nup_p +( +execu +) \ + +605 +__ame +. +__do_ + = ( +execu +); \ + +606 } 0) + + ) + +608 #ifde +__USE_GNU + + +612  + #had_nup_push_der_ +( +route +, +g +) \ + +614  +__had_nup_ame + +__ame + \ + +615 + `__ibu__ + (( + `__nup__ + ( +__had_nup_route +))) \ + +616 { . +__nl_route + = ( +route +), . +__nl_g + = ( +g +), \ + +617 . +__do_ + = 1 }; \ + +618 ( + `had_tny + ( +PTHREAD_CANCEL_DEFERRED +, \ + +619 & +__ame +. +__nl_ty +) + + ) + +624  + #had_nup_p_e_ +( +execu +) \ + +625 ( + `had_tny + ( +__ame +. +__nl_ty +, +NULL +); \ + +626 +__ame +. +__do_ + = ( +execu +); \ + +627 } 0) + + ) + +638  + #had_nup_push +( +route +, +g +) \ + +640 +__had_unwd_buf_t + +__nl_buf +; \ + +641 (* +__nl_route +(*( +route +); \ + +642 * +__nl_g + = ( +g +); \ + +643  +n_f_ + = + `__sigtjmp + (( +__jmp_buf_g + *) (*) \ + +644 +__nl_buf +. +__nl_jmp_buf +, 0); \ + +645 i( + `__but_ex + ( +n_f_ +, 0)) \ + +647 + `__nl_route + ( +__nl_g +); \ + +648 + `__had_unwd_xt + (& +__nl_buf +); \ + +652 + `__had_gi_nl + (& +__nl_buf +); \ + +653 d{ + + ) + +654  +__had_gi_nl + ( +__had_unwd_buf_t + * +__buf +) + +655 +__nup_f_ibu +; + +659  + #had_nup_p +( +execu +) \ + +662 + `__had_uegi_nl + (& +__nl_buf +); \ + +663 i( +execu +) \ + +664 + `__nl_route + ( +__nl_g +); \ + +665 } 0) + + ) + +666  + $__had_uegi_nl + ( +__had_unwd_buf_t + * +__buf +) + +667 +__nup_f_ibu +; + +669 #ifde +__USE_GNU + + +673  + #had_nup_push_der_ +( +route +, +g +) \ + +675 +__had_unwd_buf_t + +__nl_buf +; \ + +676 (* +__nl_route +(*( +route +); \ + +677 * +__nl_g + = ( +g +); \ + +678  +n_f_ + = + `__sigtjmp + (( +__jmp_buf_g + *) (*) \ + +679 +__nl_buf +. +__nl_jmp_buf +, 0); \ + +680 i( + `__but_ex + ( +n_f_ +, 0)) \ + +682 + `__nl_route + ( +__nl_g +); \ + +683 + `__had_unwd_xt + (& +__nl_buf +); \ + +687 + `__had_gi_nl_der + (& +__nl_buf +); \ + +688 d{ + + ) + +689  + `__had_gi_nl_der + ( +__had_unwd_buf_t + * +__buf +) + +690 +__nup_f_ibu +; + +695  + #had_nup_p_e_ +( +execu +) \ + +698 + `__had_uegi_nl_e + (& +__nl_buf +); \ + +699 i( +execu +) \ + +700 + `__nl_route + ( +__nl_g +); \ + +701 + } +} 0) + + ) + +702  + $__had_uegi_nl_e + ( +__had_unwd_buf_t + * +__buf +) + +703 +__nup_f_ibu +; + +707  + $__had_unwd_xt + ( +__had_unwd_buf_t + * +__buf +) + +708 +__nup_f_ibu + + `__ibu__ + (( +__nܑu__ +)) + +709 #ide +SHARED + + +710 + `__ibu__ + (( +__wk__ +)) + +716  +__jmp_buf_g +; + +717  + $__sigtjmp + ( +__jmp_buf_g + * +__v +,  +__vemask + +__THROW +; + +723  + $had_mux_ + ( +had_mux_t + * +__mux +, + +724 +__cڡ + +had_mux_t + * +__mux +) + +725 +__THROW + + `__nnu + ((1)); + +728  + $had_mux_deroy + ( +had_mux_t + * +__mux +) + +729 +__THROW + + `__nnu + ((1)); + +732  + $had_mux_ylock + ( +had_mux_t + * +__mux +) + +733 +__THROW + + `__nnu + ((1)); + +736  + $had_mux_lock + ( +had_mux_t + * +__mux +) + +737 +__THROW + + `__nnu + ((1)); + +739 #ifde +__USE_XOPEN2K + + +741  + $had_mux_timedlock + ( +had_mux_t + * +__ri + +__mux +, + +742 +__cڡ +  +timeec + * +__ri + + +743 +__abime + +__THROW + + `__nnu + ((1, 2)); + +747  + $had_mux_uock + ( +had_mux_t + * +__mux +) + +748 +__THROW + + `__nnu + ((1)); + +751 #ifde +__USE_UNIX98 + + +753  + $had_mux_giog + ( +__cڡ + +had_mux_t + * + +754 +__ri + +__mux +, + +755 * +__ri + +__iog +) + +756 +__THROW + + `__nnu + ((1, 2)); + +760  + $had_mux_riog + ( +had_mux_t + * +__ri + +__mux +, + +761  +__iog +, + +762 * +__ri + +__d_g +) + +763 +__THROW + + `__nnu + ((1, 3)); + +767 #ifde +__USE_XOPEN2K8 + + +769  + $had_mux_csit_ + ( +had_mux_t + * +__mux +) + +770 +__THROW + + `__nnu + ((1)); + +771 #ifde +__USE_GNU + + +772  + $had_mux_csit_ + ( +had_mux_t + * +__mux +) + +773 +__THROW + + `__nnu + ((1)); + +782  + $had_mux_ + ( +had_mux_t + * +__ +) + +783 +__THROW + + `__nnu + ((1)); + +786  + $had_mux_deroy + ( +had_mux_t + * +__ +) + +787 +__THROW + + `__nnu + ((1)); + +790  + $had_mux_gpshed + ( +__cڡ + +had_mux_t + * + +791 +__ri + +__ +, + +792 * +__ri + +__pshed +) + +793 +__THROW + + `__nnu + ((1, 2)); + +796  + $had_mux_shed + ( +had_mux_t + * +__ +, + +797  +__pshed +) + +798 +__THROW + + `__nnu + ((1)); + +800 #ifde +__USE_UNIX98 + + +802  + $had_mux_gty + ( +__cڡ + +had_mux_t + * +__ri + + +803 +__ +, * +__ri + +__kd +) + +804 +__THROW + + `__nnu + ((1, 2)); + +809  + $had_mux_y + ( +had_mux_t + * +__ +,  +__kd +) + +810 +__THROW + + `__nnu + ((1)); + +813  + $had_mux_goc + ( +__cڡ + +had_mux_t + * + +814 +__ri + +__ +, + +815 * +__ri + +__oc +) + +816 +__THROW + + `__nnu + ((1, 2)); + +820  + $had_mux_roc + ( +had_mux_t + * +__ +, + +821  +__oc +) + +822 +__THROW + + `__nnu + ((1)); + +825  + $had_mux_giog + ( +__cڡ + +had_mux_t + * + +826 +__ri + +__ +, + +827 * +__ri + +__iog +) + +828 +__THROW + + `__nnu + ((1, 2)); + +831  + $had_mux_riog + ( +had_mux_t + * +__ +, + +832  +__iog +) + +833 +__THROW + + `__nnu + ((1)); + +836 #ifde +__USE_XOPEN2K + + +838  + $had_mux_grobu + ( +__cڡ + +had_mux_t + * +__ +, + +839 * +__robuss +) + +840 +__THROW + + `__nnu + ((1, 2)); + +841 #ifde +__USE_GNU + + +842  + $had_mux_grobu_ + ( +__cڡ + +had_mux_t + * +__ +, + +843 * +__robuss +) + +844 +__THROW + + `__nnu + ((1, 2)); + +848  + $had_mux_obu + ( +had_mux_t + * +__ +, + +849  +__robuss +) + +850 +__THROW + + `__nnu + ((1)); + +851 #ifde +__USE_GNU + + +852  + $had_mux_obu_ + ( +had_mux_t + * +__ +, + +853  +__robuss +) + +854 +__THROW + + `__nnu + ((1)); + +859 #i +defed + +__USE_UNIX98 + || defed +__USE_XOPEN2K + + +864  + $had_rwlock_ + ( +had_rwlock_t + * +__ri + +__rwlock +, + +865 +__cڡ + +had_rwlock_t + * +__ri + + +866 +__ + +__THROW + + `__nnu + ((1)); + +869  + $had_rwlock_deroy + ( +had_rwlock_t + * +__rwlock +) + +870 +__THROW + + `__nnu + ((1)); + +873  + $had_rwlock_rdlock + ( +had_rwlock_t + * +__rwlock +) + +874 +__THROW + + `__nnu + ((1)); + +877  + $had_rwlock_yrdlock + ( +had_rwlock_t + * +__rwlock +) + +878 +__THROW + + `__nnu + ((1)); + +880 #ifde +__USE_XOPEN2K + + +882  + $had_rwlock_timedrdlock + ( +had_rwlock_t + * +__ri + +__rwlock +, + +883 +__cڡ +  +timeec + * +__ri + + +884 +__abime + +__THROW + + `__nnu + ((1, 2)); + +888  + $had_rwlock_wock + ( +had_rwlock_t + * +__rwlock +) + +889 +__THROW + + `__nnu + ((1)); + +892  + $had_rwlock_ywock + ( +had_rwlock_t + * +__rwlock +) + +893 +__THROW + + `__nnu + ((1)); + +895 #ifde +__USE_XOPEN2K + + +897  + $had_rwlock_timedwock + ( +had_rwlock_t + * +__ri + +__rwlock +, + +898 +__cڡ +  +timeec + * +__ri + + +899 +__abime + +__THROW + + `__nnu + ((1, 2)); + +903  + $had_rwlock_uock + ( +had_rwlock_t + * +__rwlock +) + +904 +__THROW + + `__nnu + ((1)); + +910  + $had_rwlock_ + ( +had_rwlock_t + * +__ +) + +911 +__THROW + + `__nnu + ((1)); + +914  + $had_rwlock_deroy + ( +had_rwlock_t + * +__ +) + +915 +__THROW + + `__nnu + ((1)); + +918  + $had_rwlock_gpshed + ( +__cڡ + +had_rwlock_t + * + +919 +__ri + +__ +, + +920 * +__ri + +__pshed +) + +921 +__THROW + + `__nnu + ((1, 2)); + +924  + $had_rwlock_shed + ( +had_rwlock_t + * +__ +, + +925  +__pshed +) + +926 +__THROW + + `__nnu + ((1)); + +929  + $had_rwlock_gkd_ + ( +__cڡ + +had_rwlock_t + * + +930 +__ri + +__ +, + +931 * +__ri + +__ef +) + +932 +__THROW + + `__nnu + ((1, 2)); + +935  + $had_rwlock_tkd_ + ( +had_rwlock_t + * +__ +, + +936  +__ef + +__THROW + + `__nnu + ((1)); + +944  + $had_cd_ + ( +had_cd_t + * +__ri + +__cd +, + +945 +__cڡ + +had_cd_t + * +__ri + + +946 +__cd_ + +__THROW + + `__nnu + ((1)); + +949  + $had_cd_deroy + ( +had_cd_t + * +__cd +) + +950 +__THROW + + `__nnu + ((1)); + +953  + $had_cd_sigl + ( +had_cd_t + * +__cd +) + +954 +__THROW + + `__nnu + ((1)); + +957  + $had_cd_brd + ( +had_cd_t + * +__cd +) + +958 +__THROW + + `__nnu + ((1)); + +965  + $had_cd_wa + ( +had_cd_t + * +__ri + +__cd +, + +966 +had_mux_t + * +__ri + +__mux +) + +967 + `__nnu + ((1, 2)); + +976  + $had_cd_timedwa + ( +had_cd_t + * +__ri + +__cd +, + +977 +had_mux_t + * +__ri + +__mux +, + +978 +__cڡ +  +timeec + * +__ri + + +979 +__abime + + `__nnu + ((1, 2, 3)); + +984  + $had_cd_ + ( +had_cd_t + * +__ +) + +985 +__THROW + + `__nnu + ((1)); + +988  + $had_cd_deroy + ( +had_cd_t + * +__ +) + +989 +__THROW + + `__nnu + ((1)); + +992  + $had_cd_gpshed + ( +__cڡ + +had_cd_t + * + +993 +__ri + +__ +, + +994 * +__ri + +__pshed +) + +995 +__THROW + + `__nnu + ((1, 2)); + +998  + $had_cd_shed + ( +had_cd_t + * +__ +, + +999  +__pshed + +__THROW + + `__nnu + ((1)); + +1001 #ifde +__USE_XOPEN2K + + +1003  + $had_cd_gock + ( +__cڡ + +had_cd_t + * + +1004 +__ri + +__ +, + +1005 +__ockid_t + * +__ri + +__ock_id +) + +1006 +__THROW + + `__nnu + ((1, 2)); + +1009  + $had_cd_tock + ( +had_cd_t + * +__ +, + +1010 +__ockid_t + +__ock_id +) + +1011 +__THROW + + `__nnu + ((1)); + +1015 #ifde +__USE_XOPEN2K + + +1020  + $had__ + ( +had_lock_t + * +__lock +,  +__pshed +) + +1021 +__THROW + + `__nnu + ((1)); + +1024  + $had__deroy + ( +had_lock_t + * +__lock +) + +1025 +__THROW + + `__nnu + ((1)); + +1028  + $had__lock + ( +had_lock_t + * +__lock +) + +1029 +__THROW + + `__nnu + ((1)); + +1032  + $had__ylock + ( +had_lock_t + * +__lock +) + +1033 +__THROW + + `__nnu + ((1)); + +1036  + $had__uock + ( +had_lock_t + * +__lock +) + +1037 +__THROW + + `__nnu + ((1)); + +1044  + $had_brr_ + ( +had_brr_t + * +__ri + +__brr +, + +1045 +__cڡ + +had_brr_t + * +__ri + + +1046 +__ +,  +__cou +) + +1047 +__THROW + + `__nnu + ((1)); + +1050  + $had_brr_deroy + ( +had_brr_t + * +__brr +) + +1051 +__THROW + + `__nnu + ((1)); + +1054  + $had_brr_wa + ( +had_brr_t + * +__brr +) + +1055 +__THROW + + `__nnu + ((1)); + +1059  + $had_brr_ + ( +had_brr_t + * +__ +) + +1060 +__THROW + + `__nnu + ((1)); + +1063  + $had_brr_deroy + ( +had_brr_t + * +__ +) + +1064 +__THROW + + `__nnu + ((1)); + +1067  + $had_brr_gpshed + ( +__cڡ + +had_brr_t + * + +1068 +__ri + +__ +, + +1069 * +__ri + +__pshed +) + +1070 +__THROW + + `__nnu + ((1, 2)); + +1073  + $had_brr_shed + ( +had_brr_t + * +__ +, + +1074  +__pshed +) + +1075 +__THROW + + `__nnu + ((1)); + +1087  + `had_key_ + ( +had_key_t + * +__key +, + +1088 (* +__der_funi +) (*)) + +1089 +__THROW + + `__nnu + ((1)); + +1092  + $had_key_de + ( +had_key_t + +__key + +__THROW +; + +1095 * + $had_gecific + ( +had_key_t + +__key + +__THROW +; + +1098  + $had_tecific + ( +had_key_t + +__key +, + +1099 +__cڡ + * +__por + +__THROW + ; + +1102 #ifde +__USE_XOPEN2K + + +1104  + $had_guockid + ( +had_t + +__thad_id +, + +1105 +__ockid_t + * +__ock_id +) + +1106 +__THROW + + `__nnu + ((2)); + +1121  + `had_fk + ((* +__e +) (), + +1122 (* +__ +) (), + +1123 (* +__chd +() +__THROW +; + +1126 #ifde +__USE_EXTERN_INLINES + + +1128 +__ex_le +  + +1129 + `__NTH + ( + $had_equ + ( +had_t + +__thad1 +,thad_ +__thad2 +)) + +1131  +__thad1 + = +__thad2 +; + +1132 + } +} + +1135 + g__END_DECLS + + + @/usr/include/sys/select.h + +22 #ide +_SYS_SELECT_H + + +23  + #_SYS_SELECT_H + 1 + + ) + +25  + ~ + +28  + ~ + +31  + ~ + +34  + ~ + +36 #ide +__sigt_t_defed + + +37  + #__sigt_t_defed + + + ) + +38  +__sigt_t + + tsigt_t +; + +42  + #__ed_time_t + + + ) + +43  + #__ed_timeec + + + ) + +44  + ~ + +45  + #__ed_timev + + + ) + +46  + ~ + +48 #ide +__sucds_t_defed + + +49  +__sucds_t + + tsucds_t +; + +50  + #__sucds_t_defed + + + ) + +55  + t__fd_mask +; + +58 #unde +__NFDBITS + + +59 #unde +__FDELT + + +60 #unde +__FDMASK + + +62  + #__NFDBITS + (8 * ( ( +__fd_mask +)) + + ) + +63  + #__FDELT +( +d +((d/ +__NFDBITS +) + + ) + +64  + #__FDMASK +( +d +(( +__fd_mask +1 << ((d% +__NFDBITS +)) + + ) + +71 #ifde +__USE_XOPEN + + +72 +__fd_mask + + mfds_bs +[ +__FD_SETSIZE + / +__NFDBITS +]; + +73  + #__FDS_BITS +( +t +((t)-> +fds_bs +) + + ) + +75 +__fd_mask + + m__fds_bs +[ +__FD_SETSIZE + / +__NFDBITS +]; + +76  + #__FDS_BITS +( +t +((t)-> +__fds_bs +) + + ) + +78 } + tfd_t +; + +81  + #FD_SETSIZE + +__FD_SETSIZE + + + ) + +83 #ifde +__USE_MISC + + +85  +__fd_mask + + tfd_mask +; + +88  + #NFDBITS + +__NFDBITS + + + ) + +93  + #FD_SET +( +fd +, +fd + + `__FD_SET + (fd, fd) + + ) + +94  + #FD_CLR +( +fd +, +fd + + `__FD_CLR + (fd, fd) + + ) + +95  + #FD_ISSET +( +fd +, +fd + + `__FD_ISSET + (fd, fd) + + ) + +96  + #FD_ZERO +( +fd + + `__FD_ZERO + (fd) + + ) + +99 +__BEGIN_DECLS + + +109  + + ( +__nfds +, +fd_t + * +__ri + +__adfds +, + +110 +fd_t + * +__ri + +__wrefds +, + +111 +fd_t + * +__ri + +__exfds +, + +112  +timev + * +__ri + +__timeout +); + +114 #ifde +__USE_XOPEN2K + + +121  +p + ( +__nfds +, +fd_t + * +__ri + +__adfds +, + +122 +fd_t + * +__ri + +__wrefds +, + +123 +fd_t + * +__ri + +__exfds +, + +124 cڡ  +timeec + * +__ri + +__timeout +, + +125 cڡ +__sigt_t + * +__ri + +__sigmask +); + +128 + g__END_DECLS + + + @/usr/include/sys/sysmacros.h + +21 #ide +_SYS_SYSMACROS_H + + +22  + #_SYS_SYSMACROS_H + 1 + + ) + +24  + ~ + +29 #ifde +__GLIBC_HAVE_LONG_LONG + + +30 +__exnsi__ + + +31  + $gnu_dev_maj + ( +__dev +) + +32 +__THROW +; + +33 +__exnsi__ + + +34  + $gnu_dev_m + ( +__dev +) + +35 +__THROW +; + +36 +__exnsi__ + + +37  + $gnu_dev_makedev + ( +__maj +, + +38  +__m +) + +39 +__THROW +; + +41 #i +defed + +__GNUC__ + && __GNUC__ >2 && defed +__USE_EXTERN_INLINES + + +42 +__exnsi__ + +__ex_le +  + +43 + `__NTH + ( + $gnu_dev_maj + ( +__dev +)) + +45  (( +__dev + >> 8) & 0xfff) | (() (__dev >> 32) & ~0xfff); + +46 + } +} + +48 +__exnsi__ + +__ex_le +  + +49 +__NTH + ( + $gnu_dev_m + ( +__dev +)) + +51  ( +__dev + & 0xff) | (() (__dev >> 12) & ~0xff); + +52 + } +} + +54 +__exnsi__ + +__ex_le +  + +55 +__NTH + ( + $gnu_dev_makedev + ( +__maj +,  +__m +)) + +57  (( +__m + & 0xff| (( +__maj + & 0xfff) << 8) + +58 | (((( +__m + & ~0xff)) << 12) + +59 | (((( +__maj + & ~0xfff)) << 32)); + +60 + } +} + +65  + #maj +( +dev + + `gnu_dev_maj + (dev) + + ) + +66  + #m +( +dev + + `gnu_dev_m + (dev) + + ) + +67  + #makedev +( +maj +, +m + + `gnu_dev_makedev + (maj, m) + + ) + + @/usr/include/time.h + +23 #idef +_TIME_H + + +25 #i(! +defed + +__ed_time_t + && !defed +__ed_ock_t + && \ + +26 ! +defed + + g__ed_timeec +) + +27  + #_TIME_H + 1 + + ) + +28  + ~ + +30 + g__BEGIN_DECLS + + +34 #ifdef +_TIME_H + + +36  + #__ed_size_t + + + ) + +37  + #__ed_NULL + + + ) + +38  + ~ + +42  + ~ + +45 #i! +defed + +__STRICT_ANSI__ + && !defed +__USE_XOPEN2K + + +46 #ide +CLK_TCK + + +47  + #CLK_TCK + +CLOCKS_PER_SEC + + + ) + +53 #i! +defed + +__ock_t_defed + && (defed +_TIME_H + || defed +__ed_ock_t +) + +54  + #__ock_t_defed + 1 + + ) + +56  + ~ + +58 +__BEGIN_NAMESPACE_STD + + +60  +__ock_t + + tock_t +; + +61 + g__END_NAMESPACE_STD + + +62 #i +defed + +__USE_XOPEN + || defed +__USE_POSIX + || defed +__USE_MISC + + +63 + $__USING_NAMESPACE_STD +( +ock_t +) + +67 #unde +__ed_ock_t + + +69 #i! +defed + +__time_t_defed + && (defed +_TIME_H + || defed +__ed_time_t +) + +70  + #__time_t_defed + 1 + + ) + +72  + ~ + +74 +__BEGIN_NAMESPACE_STD + + +76  +__time_t + + ttime_t +; + +77 +__END_NAMESPACE_STD + + +78 #i +defed + +__USE_POSIX + || defed +__USE_MISC + || defed +__USE_SVID + + +79 + $__USING_NAMESPACE_STD +( +time_t +) + +83 #unde +__ed_time_t + + +85 #i! +defed + +__ockid_t_defed + && \ + +86 (( +defed + +_TIME_H + && defed +__USE_POSIX199309 +|| defed +__ed_ockid_t +) + +87  + #__ockid_t_defed + 1 + + ) + +89  + ~ + +92  +__ockid_t + + tockid_t +; + +95 #unde +__ockid_time_t + + +97 #i! +defed + +__tim_t_defed + && \ + +98 (( +defed + +_TIME_H + && defed +__USE_POSIX199309 +|| defed +__ed_tim_t +) + +99  + #__tim_t_defed + 1 + + ) + +101  + ~ + +104  +__tim_t + + ttim_t +; + +107 #unde +__ed_tim_t + + +110 #i! +defed + +__timeec_defed + && \ + +111 (( +defed + +_TIME_H + && \ + +112 ( +defed + +__USE_POSIX199309 + || defed +__USE_MISC +)) || \ + +113 +defed + +__ed_timeec +) + +114  + #__timeec_defed + 1 + + ) + +116  + ~ + +120  + stimeec + + +122 +__time_t + +tv_c +; + +123  +tv_nc +; + +127 #unde +__ed_timeec + + +130 #ifdef +_TIME_H + + +131 +__BEGIN_NAMESPACE_STD + + +133  + stm + + +135  +tm_c +; + +136  +tm_m +; + +137  +tm_hour +; + +138  +tm_mday +; + +139  +tm_m +; + +140  +tm_yr +; + +141  +tm_wday +; + +142  +tm_yday +; + +143  +tm_isd +; + +145 #ifdef +__USE_BSD + + +146  +tm_gmtoff +; + +147 +__cڡ + * +tm_ze +; + +149  +__tm_gmtoff +; + +150 +__cڡ + * +__tm_ze +; + +153 +__END_NAMESPACE_STD + + +154 #i +defed + +__USE_XOPEN + || defed +__USE_POSIX + || defed +__USE_MISC + + +155 + $__USING_NAMESPACE_STD +( +tm +) + +159 #ifde +__USE_POSIX199309 + + +161  + simec + + +163  +timeec + +_rv +; + +164  +timeec + +_vue +; + +168  +sigevt +; + +172 #ifde +__USE_XOPEN2K + + +173 #ide +__pid_t_defed + + +174  +__pid_t + + tpid_t +; + +175  + #__pid_t_defed + + + ) + +180 +__BEGIN_NAMESPACE_STD + + +183 +ock_t + + $ock + ( +__THROW +; + +186 +time_t + + $time + ( +time_t + * +__tim + +__THROW +; + +189  + $difime + ( +time_t + +__time1 +,ime_ +__time0 +) + +190 +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +193 +time_t + + $mktime + ( +tm + * +__ + +__THROW +; + +199 +size_t + + $rime + (* +__ri + +__s +, +size_t + +__maxsize +, + +200 +__cڡ + * +__ri + +__fm +, + +201 +__cڡ +  +tm + * +__ri + +__ + +__THROW +; + +202 +__END_NAMESPACE_STD + + +204 #ifde +__USE_XOPEN + + +207 * + $time + ( +__cڡ + * +__ri + +__s +, + +208 +__cڡ + * +__ri + +__fmt +,  +tm + * +__ +) + +209 +__THROW +; + +212 #ifde +__USE_XOPEN2K8 + + +215  + ~ + +217 +size_t + + $rime_l + (* +__ri + +__s +, +size_t + +__maxsize +, + +218 +__cڡ + * +__ri + +__fm +, + +219 +__cڡ +  +tm + * +__ri + +__ +, + +220 +__lo_t + +__loc + +__THROW +; + +223 #ifde +__USE_GNU + + +224 * + $time_l + ( +__cڡ + * +__ri + +__s +, + +225 +__cڡ + * +__ri + +__fmt +,  +tm + * +__ +, + +226 +__lo_t + +__loc + +__THROW +; + +230 +__BEGIN_NAMESPACE_STD + + +233  +tm + * + $gmtime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +237  +tm + * + $loime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +238 +__END_NAMESPACE_STD + + +240 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +243  +tm + * + $gmtime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +244  +tm + * +__ri + +__ + +__THROW +; + +248  +tm + * + $loime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +249  +tm + * +__ri + +__ + +__THROW +; + +252 +__BEGIN_NAMESPACE_STD + + +255 * + $asime + ( +__cڡ +  +tm + * +__ + +__THROW +; + +258 * + $ime + ( +__cڡ + +time_t + * +__tim + +__THROW +; + +259 +__END_NAMESPACE_STD + + +261 #i +defed + +__USE_POSIX + || defed +__USE_MISC + + +266 * + $asime_r + ( +__cڡ +  +tm + * +__ri + +__ +, + +267 * +__ri + +__buf + +__THROW +; + +270 * + $ime_r + ( +__cڡ + +time_t + * +__ri + +__tim +, + +271 * +__ri + +__buf + +__THROW +; + +276 * +__tzme +[2]; + +277  +__daylight +; + +278  +__timeze +; + +281 #ifdef +__USE_POSIX + + +283 * +tzme +[2]; + +287  + $tzt + ( +__THROW +; + +290 #i +defed + +__USE_SVID + || defed +__USE_XOPEN + + +291  +daylight +; + +292  +timeze +; + +295 #ifde +__USE_SVID + + +298  + $ime + ( +__cڡ + +time_t + * +__wh + +__THROW +; + +304  + #__ip +( +yr +) \ + +305 (( +yr +% 4 =0 && ((yr% 100 !0 || (yr% 400 =0)) + + ) + +308 #ifde +__USE_MISC + + +313 +time_t + + $timegm + ( +tm + * +__ + +__THROW +; + +316 +time_t + + $timol + ( +tm + * +__ + +__THROW +; + +319  + $dysize + ( +__yr + +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +323 #ifde +__USE_POSIX199309 + + +328  + `nop + ( +__cڡ +  +timeec + * +__queed_time +, + +329  +timeec + * +__mag +); + +333  + $ock_gs + ( +ockid_t + +__ock_id +,  +timeec + * +__s + +__THROW +; + +336  + $ock_gtime + ( +ockid_t + +__ock_id +,  +timeec + * +__ + +__THROW +; + +339  + $ock_ime + ( +ockid_t + +__ock_id +, +__cڡ +  +timeec + * +__ +) + +340 +__THROW +; + +342 #ifde +__USE_XOPEN2K + + +347  + `ock_nop + ( +ockid_t + +__ock_id +,  +__ags +, + +348 +__cڡ +  +timeec + * +__q +, + +349  +timeec + * +__m +); + +352  + $ock_guockid + ( +pid_t + +__pid +, +ockid_t + * +__ock_id + +__THROW +; + +357  + $tim_ + ( +ockid_t + +__ock_id +, + +358  +sigevt + * +__ri + +__evp +, + +359 +tim_t + * +__ri + +__timid + +__THROW +; + +362  + $tim_de + ( +tim_t + +__timid + +__THROW +; + +365  + $tim_ime + ( +tim_t + +__timid +,  +__ags +, + +366 +__cڡ +  +imec + * +__ri + +__vue +, + +367  +imec + * +__ri + +__ovue + +__THROW +; + +370  + $tim_gtime + ( +tim_t + +__timid +,  +imec + * +__vue +) + +371 +__THROW +; + +374  + $tim_govrun + ( +tim_t + +__timid + +__THROW +; + +378 #ifde +__USE_XOPEN_EXTENDED + + +390  +gde_r +; + +399  +tm + * + `gde + ( +__cڡ + * +__rg +); + +402 #ifde +__USE_GNU + + +413  + `gde_r + ( +__cڡ + * +__ri + +__rg +, + +414  +tm + * +__ri + +__sbu +); + +417 +__END_DECLS + + + @/usr/include/wctype.h + +24 #ide +_WCTYPE_H + + +26  + ~ + +27  + ~ + +29 #ide +__ed_iswxxx + + +30  + #_WCTYPE_H + 1 + + ) + +33  + #__ed_wt_t + + + ) + +34  + ~ + +38 #ide +WEOF + + +39  + #WEOF + (0xffffffffu) + + ) + +42 #unde +__ed_iswxxx + + +47 #ide +__iswxxx_defed + + +48  + #__iswxxx_defed + 1 + + ) + +50 +__BEGIN_NAMESPACE_C99 + + +53  + twy_t +; + +54 + g__END_NAMESPACE_C99 + + +56 #ide +_ISwb + + +61  + ~ + +62 #i +__BYTE_ORDER + = +__BIG_ENDIAN + + +63  + #_ISwb +( +b +(1 << (b)) + + ) + +65  + #_ISwb +( +b +) \ + +66 (( +b +) < 8 ? () ((1UL << (bit)) << 24) \ + +67 : (( +b +) < 16 ? () ((1UL << (bit)) << 8) \ + +68 : (( +b +) < 24 ? () ((1UL << (bit)) >> 8) \ + +69 : (((1UL << ( +b +)>> 24)))) + + ) + +74 + m__ISwu + = 0, + +75 + m__ISwlow + = 1, + +76 + m__ISwpha + = 2, + +77 + m__ISwdig + = 3, + +78 + m__ISwxdig + = 4, + +79 + m__ISwa + = 5, + +80 + m__ISwt + = 6, + +81 + m__ISwgph + = 7, + +82 + m__ISwbnk + = 8, + +83 + m__ISwl + = 9, + +84 + m__ISwpun + = 10, + +85 + m__ISwnum + = 11, + +87 + m_ISwu + = +_ISwb + ( +__ISwu +), + +88 + m_ISwlow + = +_ISwb + ( +__ISwlow +), + +89 + m_ISwpha + = +_ISwb + ( +__ISwpha +), + +90 + m_ISwdig + = +_ISwb + ( +__ISwdig +), + +91 + m_ISwxdig + = +_ISwb + ( +__ISwxdig +), + +92 + m_ISwa + = +_ISwb + ( +__ISwa +), + +93 + m_ISwt + = +_ISwb + ( +__ISwt +), + +94 + m_ISwgph + = +_ISwb + ( +__ISwgph +), + +95 + m_ISwbnk + = +_ISwb + ( +__ISwbnk +), + +96 + m_ISwl + = +_ISwb + ( +__ISwl +), + +97 + m_ISwpun + = +_ISwb + ( +__ISwpun +), + +98 + m_ISwnum + = +_ISwb + ( +__ISwnum +) + +103 +__BEGIN_DECLS + + +105 +__BEGIN_NAMESPACE_C99 + + +112  + $iswnum + ( +wt_t + +__wc + +__THROW +; + +118  + $iswpha + ( +wt_t + +__wc + +__THROW +; + +121  + $iswl + ( +wt_t + +__wc + +__THROW +; + +125  + $iswdig + ( +wt_t + +__wc + +__THROW +; + +129  + $iswgph + ( +wt_t + +__wc + +__THROW +; + +134  + $iswlow + ( +wt_t + +__wc + +__THROW +; + +137  + $iswt + ( +wt_t + +__wc + +__THROW +; + +142  + $iswpun + ( +wt_t + +__wc + +__THROW +; + +147  + $iswa + ( +wt_t + +__wc + +__THROW +; + +152  + $iswu + ( +wt_t + +__wc + +__THROW +; + +157  + $iswxdig + ( +wt_t + +__wc + +__THROW +; + +162 #ifde +__USE_ISOC99 + + +163  + $iswbnk + ( +wt_t + +__wc + +__THROW +; + +172 +wy_t + + $wy + ( +__cڡ + * +__ݔty + +__THROW +; + +176  + $iswy + ( +wt_t + +__wc +, +wy_t + +__desc + +__THROW +; + +177 +__END_NAMESPACE_C99 + + +184 +__BEGIN_NAMESPACE_C99 + + +187  +__cڡ + + t__t32_t + * + twns_t +; + +188 +__END_NAMESPACE_C99 + + +189 #ifde +__USE_GNU + + +190 + $__USING_NAMESPACE_C99 +( +wns_t +) + +193 +__BEGIN_NAMESPACE_C99 + + +195 +wt_t + + $towlow + ( +wt_t + +__wc + +__THROW +; + +198 +wt_t + + $towu + ( +wt_t + +__wc + +__THROW +; + +199 +__END_NAMESPACE_C99 + + +201 +__END_DECLS + + +208 #ifde +_WCTYPE_H + + +214 +__BEGIN_DECLS + + +216 +__BEGIN_NAMESPACE_C99 + + +219 +wns_t + + $wns + ( +__cڡ + * +__ݔty + +__THROW +; + +222 +wt_t + + $towns + ( +wt_t + +__wc +, +wns_t + +__desc + +__THROW +; + +223 +__END_NAMESPACE_C99 + + +225 #ifde +__USE_XOPEN2K8 + + +227  + ~ + +231  + $iswnum_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +237  + $iswpha_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +240  + $iswl_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +244  + $iswdig_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +248  + $iswgph_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +253  + $iswlow_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +256  + $iswt_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +261  + $iswpun_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +266  + $iswa_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +271  + $iswu_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +276  + $iswxdig_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +281  + $iswbnk_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +285 +wy_t + + $wy_l + ( +__cڡ + * +__ݔty +, +__lo_t + +__lo +) + +286 +__THROW +; + +290  + $iswy_l + ( +wt_t + +__wc +, +wy_t + +__desc +, +__lo_t + +__lo +) + +291 +__THROW +; + +299 +wt_t + + $towlow_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +302 +wt_t + + $towu_l + ( +wt_t + +__wc +, +__lo_t + +__lo + +__THROW +; + +306 +wns_t + + $wns_l + ( +__cڡ + * +__ݔty +, +__lo_t + +__lo +) + +307 +__THROW +; + +310 +wt_t + + $towns_l + ( +wt_t + +__wc +, +wns_t + +__desc +, + +311 +__lo_t + +__lo + +__THROW +; + +315 +__END_DECLS + + + @/usr/include/bits/errno.h + +20 #ifde +_ERRNO_H + + +22 #unde +EDOM + + +23 #unde +EILSEQ + + +24 #unde +ERANGE + + +25  + ~ + +28  + #ENOTSUP + +EOPNOTSUPP + + + ) + +31 #ide +ECANCELED + + +32  + #ECANCELED + 125 + + ) + +36 #ide +EOWNERDEAD + + +37  + #EOWNERDEAD + 130 + + ) + +38  + #ENOTRECOVERABLE + 131 + + ) + +41 #ide +__ASSEMBLER__ + + +43 * + $__o_loti + ( +__THROW + + `__ibu__ + (( +__cڡ__ +)); + +45 #i! +defed + +_LIBC + || defed +_LIBC_REENTRANT + + +47  + #o + (* + `__o_loti + ()) + + ) + +52 #i! +defed + +_ERRNO_H + && defed +__ed_Emh + + +56  + #EDOM + 33 + + ) + +57  + #EILSEQ + 84 + + ) + +58  + #ERANGE + 34 + + ) + + @/usr/include/bits/select.h + +19 #ide +_SYS_SELECT_H + + +23  + ~ + +26 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +28 #i +__WORDSIZE + == 64 + +29  + #__FD_ZERO_STOS + "osq" + + ) + +31  + #__FD_ZERO_STOS + "o" + + ) + +34  + #__FD_ZERO +( +fd +) \ + +36  +__d0 +, +__d1 +; \ + +37 +__asm__ + + `__vީe__ + ("d;; " +__FD_ZERO_STOS + \ + +38 : "=c" ( +__d0 +), "=D" ( +__d1 +) \ + +39 : "a" (0), "0" ( ( +fd_t +) \ + +40 /  ( +__fd_mask +)), \ + +41 "1" (& + `__FDS_BITS + ( +fd +)[0]) \ + +43 } 0) + + ) + +49  + #__FD_ZERO +( +t +) \ + +51  +__i +; \ + +52 +fd_t + * +__r + = ( +t +); \ + +53  +__i + = 0; __<  ( +fd_t +/  ( +__fd_mask +); ++__i) \ + +54 + `__FDS_BITS + ( +__r +)[ +__i +] = 0; \ + +55 } 0) + + ) + +59  + #__FD_SET +( +d +, +t +( + `__FDS_BITS + (t)[ + `__FDELT + (d)] | + `__FDMASK + (d)) + + ) + +60  + #__FD_CLR +( +d +, +t +( + `__FDS_BITS + (t)[ + `__FDELT + (d)] &~ + `__FDMASK + (d)) + + ) + +61  + #__FD_ISSET +( +d +, +t +) \ + +62 (( + `__FDS_BITS + ( +t +)[ + `__FDELT + ( +d +)] & + `__FDMASK + (d)!0) + + ) + + @/usr/include/bits/setjmp.h + +20 #ide +_BITS_SETJMP_H + + +21  + #_BITS_SETJMP_H + 1 + + ) + +23 #i! +defed + +_SETJMP_H + && !defed +_PTHREAD_H + + +27  + ~ + +29 #ide +_ASM + + +31 #i +__WORDSIZE + == 64 + +32  + t__jmp_buf +[8]; + +34  + t__jmp_buf +[6]; + + @/usr/include/bits/sigset.h + +21 #idef +_SIGSET_H_tys + + +22  + #_SIGSET_H_tys + 1 + + ) + +24  + t__sig_omic_t +; + +28  + #_SIGSET_NWORDS + (1024 / (8 *  ())) + + ) + +31  + m__v +[ +_SIGSET_NWORDS +]; + +32 } + t__sigt_t +; + +43 #i! +defed + +_SIGSET_H_s + && defed +_SIGNAL_H + + +44  + #_SIGSET_H_s + 1 + + ) + +46 #ide +_EXTERN_INLINE + + +47  + #_EXTERN_INLINE + +__ex_le + + + ) + +51  + #__sigmask +( +sig +) \ + +52 (((1<< ((( +sig +- 1% (8 *  ()))) + + ) + +55  + #__sigwd +( +sig +(((sig- 1/ (8 *  ())) + + ) + +57 #i +defed + +__GNUC__ + && __GNUC__ >= 2 + +58  + #__sigemyt +( +t +) \ + +59 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +60 +sigt_t + * +__t + = ( +t +); \ + +61 -- +__t + >0 +__t +-> +__v +[__cnt] = 0; \ + +62 0; })) + + ) + +63  + #__sigflt +( +t +) \ + +64 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +65 +sigt_t + * +__t + = ( +t +); \ + +66 -- +__t + >0 +__t +-> +__v +[__cnt] = ~0UL; \ + +67 0; })) + + ) + +69 #ifde +__USE_GNU + + +73  + #__sigimyt +( +t +) \ + +74 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +75 cڡ +sigt_t + * +__t + = ( +t +); \ + +76  +__t + = +__t +-> +__v +[-- +__t +]; \ + +77 ! +__t + && -- +__t + >= 0) \ + +78 +__t + = +__t +-> +__v +[ +__t +]; \ + +79 +__t + =0; })) + + ) + +80  + #__sigdt +( +de +, + +, +right +) \ + +81 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +82 +sigt_t + * +__de + = ( +de +); \ + +83 cڡ +sigt_t + * +__ + = ( + +); \ + +84 cڡ +sigt_t + * +__right + = ( +right +); \ + +85 -- +__t + >= 0) \ + +86 +__de +-> +__v +[ +__t +] = ( +__ +->__val[__cnt] \ + +87 & +__right +-> +__v +[ +__t +]); \ + +88 0; })) + + ) + +89  + #__sigܣt +( +de +, + +, +right +) \ + +90 ( + `__exnsi__ + ({  +__t + = +_SIGSET_NWORDS +; \ + +91 +sigt_t + * +__de + = ( +de +); \ + +92 cڡ +sigt_t + * +__ + = ( + +); \ + +93 cڡ +sigt_t + * +__right + = ( +right +); \ + +94 -- +__t + >= 0) \ + +95 +__de +-> +__v +[ +__t +] = ( +__ +->__val[__cnt] \ + +96 | +__right +-> +__v +[ +__t +]); \ + +97 0; })) + + ) + +104  +__sigismemb + ( +__cڡ + +__sigt_t + *, ); + +105  +__sigaddt + ( +__sigt_t + *, ); + +106  +__sigdt + ( +__sigt_t + *, ); + +108 #ifde +__USE_EXTERN_INLINES + + +109  + #__SIGSETFN +( +NAME +, +BODY +, +CONST +) \ + +110 +_EXTERN_INLINE + \ + +111 + `NAME + ( +CONST + +__sigt_t + * +__t +,  +__sig +) \ + +113  +__mask + = + `__sigmask + ( +__sig +); \ + +114  +__wd + = + `__sigwd + ( +__sig +); \ + +115  +BODY +; \ + +116 } + + ) + +118 +__SIGSETFN + ( +__sigismemb +, ( +__t +-> +__v +[ +__wd +] & +__mask +? 1 : 0, +__cڡ +) + +119 +__SIGSETFN + ( +__sigaddt +, (( +__t +-> +__v +[ +__wd +] | +__mask +), 0), ) + +120 +__SIGSETFN + ( +__sigdt +, (( +__t +-> +__v +[ +__wd +] &~ +__mask +), 0), ) + +122 #unde +__SIGSETFN + + + @/usr/include/bits/time.h + +24 #ide +__ed_timev + + +25 #ide +_BITS_TIME_H + + +26  + #_BITS_TIME_H + 1 + + ) + +34  + #CLOCKS_PER_SEC + 1000000l + + ) + +36 #i! +defed + +__STRICT_ANSI__ + && !defed +__USE_XOPEN2K + + +39  + ~ + +40  +__syscf + (); + +41  + #CLK_TCK + (( +__ock_t + + `__syscf + (2) + + ) + +44 #ifde +__USE_POSIX199309 + + +46  + #CLOCK_REALTIME + 0 + + ) + +48  + #CLOCK_MONOTONIC + 1 + + ) + +50  + #CLOCK_PROCESS_CPUTIME_ID + 2 + + ) + +52  + #CLOCK_THREAD_CPUTIME_ID + 3 + + ) + +55  + #TIMER_ABSTIME + 1 + + ) + +61 #ifde +__ed_timev + + +62 #unde +__ed_timev + + +63 #ide +_STRUCT_TIMEVAL + + +64  + #_STRUCT_TIMEVAL + 1 + + ) + +65  + ~ + +69  + stimev + + +71 +__time_t + + mtv_c +; + +72 +__sucds_t + + mtv_uc +; + + @/usr/include/sched.h + +20 #idef +_SCHED_H + + +21  + #_SCHED_H + 1 + + ) + +23  + ~ + +26  + ~ + +28  + #__ed_size_t + + + ) + +29  + ~ + +31  + #__ed_timeec + + + ) + +32  + ~ + +35  + ~ + +37  + #sched_iܙy + +__sched_iܙy + + + ) + +40 +__BEGIN_DECLS + + +43  + $sched_am + ( +__pid_t + +__pid +, +__cڡ +  +sched_m + * +__m +) + +44 +__THROW +; + +47  + $sched_gm + ( +__pid_t + +__pid +,  +sched_m + * +__m + +__THROW +; + +50  + $sched_tschedur + ( +__pid_t + +__pid +,  +__picy +, + +51 +__cڡ +  +sched_m + * +__m + +__THROW +; + +54  + $sched_gschedur + ( +__pid_t + +__pid + +__THROW +; + +57  + $sched_yld + ( +__THROW +; + +60  + $sched_g_iܙy_max + ( +__gܙhm + +__THROW +; + +63  + $sched_g_iܙy_m + ( +__gܙhm + +__THROW +; + +66  + $sched__g_rv + ( +__pid_t + +__pid +,  +timeec + * +__t + +__THROW +; + +69 #ifde +__USE_GNU + + +71  + #CPU_SETSIZE + +__CPU_SETSIZE + + + ) + +72  + #CPU_SET +( +u +, +u + + `__CPU_SET_S + (u,  ( +u_t_t +), cpu) + + ) + +73  + #CPU_CLR +( +u +, +u + + `__CPU_CLR_S + (u,  ( +u_t_t +), cpu) + + ) + +74  + #CPU_ISSET +( +u +, +u + + `__CPU_ISSET_S + (u,  ( +u_t_t +), \ + +75 +u +) + + ) + +76  + #CPU_ZERO +( +u + + `__CPU_ZERO_S + ( ( +u_t_t +), cpu) + + ) + +77  + #CPU_COUNT +( +u + + `__CPU_COUNT_S + ( ( +u_t_t +), cpu) + + ) + +79  + #CPU_SET_S +( +u +, +tsize +, +u + + `__CPU_SET_S + (u, ssize, cpu) + + ) + +80  + #CPU_CLR_S +( +u +, +tsize +, +u + + `__CPU_CLR_S + (u, ssize, cpu) + + ) + +81  + #CPU_ISSET_S +( +u +, +tsize +, +u + + `__CPU_ISSET_S + (cpu, setsize, \ + +82 +u +) + + ) + +83  + #CPU_ZERO_S +( +tsize +, +u + + `__CPU_ZERO_S + (tsize, cpu) + + ) + +84  + #CPU_COUNT_S +( +tsize +, +u + + `__CPU_COUNT_S + (tsize, cpu) + + ) + +86  + #CPU_EQUAL +( +u1 +, +u2 +) \ + +87 + `__CPU_EQUAL_S + ( ( +u_t_t +), +u1 +, +u2 +) + + ) + +88  + #CPU_EQUAL_S +( +tsize +, +u1 +, +u2 +) \ + +89 + `__CPU_EQUAL_S + ( +tsize +, +u1 +, +u2 +) + + ) + +91  + #CPU_AND +( +det +, +ct1 +, +ct2 +) \ + +92 + `__CPU_OP_S + ( ( +u_t_t +), +det +, +ct1 +, +ct2 +, &) + + ) + +93  + #CPU_OR +( +det +, +ct1 +, +ct2 +) \ + +94 + `__CPU_OP_S + ( ( +u_t_t +), +det +, +ct1 +, +ct2 +, |) + + ) + +95  + #CPU_XOR +( +det +, +ct1 +, +ct2 +) \ + +96 + `__CPU_OP_S + ( ( +u_t_t +), +det +, +ct1 +, +ct2 +, ^) + + ) + +97  + #CPU_AND_S +( +tsize +, +det +, +ct1 +, +ct2 +) \ + +98 + `__CPU_OP_S + ( +tsize +, +det +, +ct1 +, +ct2 +, &) + + ) + +99  + #CPU_OR_S +( +tsize +, +det +, +ct1 +, +ct2 +) \ + +100 + `__CPU_OP_S + ( +tsize +, +det +, +ct1 +, +ct2 +, |) + + ) + +101  + #CPU_XOR_S +( +tsize +, +det +, +ct1 +, +ct2 +) \ + +102 + `__CPU_OP_S + ( +tsize +, +det +, +ct1 +, +ct2 +, ^) + + ) + +104  + #CPU_ALLOC_SIZE +( +cou + + `__CPU_ALLOC_SIZE + (cou) + + ) + +105  + #CPU_ALLOC +( +cou + + `__CPU_ALLOC + (cou) + + ) + +106  + #CPU_FREE +( +ut + + `__CPU_FREE + (ut) + + ) + +110  + $sched_ffy + ( +__pid_t + +__pid +, +size_t + +__utsize +, + +111 +__cڡ + +u_t_t + * +__ut + +__THROW +; + +114  + $sched_gaffy + ( +__pid_t + +__pid +, +size_t + +__utsize +, + +115 +u_t_t + * +__ut + +__THROW +; + +118 +__END_DECLS + + + @/usr/include/signal.h + +23 #idef +_SIGNAL_H + + +25 #i! +defed + +__ed_sig_omic_t + && !defed +__ed_sigt_t + + +26  + #_SIGNAL_H + + + ) + +29  + ~ + +31 + g__BEGIN_DECLS + + +33  + ~ + +37 #i +defed + +__ed_sig_omic_t + || defed +_SIGNAL_H + + +38 #ide +__sig_omic_t_defed + + +39  + #__sig_omic_t_defed + + + ) + +40 +__BEGIN_NAMESPACE_STD + + +41  +__sig_omic_t + + tsig_omic_t +; + +42 + g__END_NAMESPACE_STD + + +44 #unde +__ed_sig_omic_t + + +47 #i +defed + +__ed_sigt_t + || (defed +_SIGNAL_H + && defed +__USE_POSIX +) + +48 #ide +__sigt_t_defed + + +49  + #__sigt_t_defed + + + ) + +50  +__sigt_t + + tsigt_t +; + +52 #unde +__ed_sigt_t + + +55 #ifde +_SIGNAL_H + + +57  + ~ + +58  + ~ + +60 #i +defed + +__USE_XOPEN + || defed +__USE_XOPEN2K + + +61 #ide +__pid_t_defed + + +62  +__pid_t + + tpid_t +; + +63  + #__pid_t_defed + + + ) + +65 #ifde +__USE_XOPEN + + +67 #ide +__uid_t_defed + + +68  +__uid_t + + tuid_t +; + +69  + #__uid_t_defed + + + ) + +73 #ifde +__USE_POSIX199309 + + +75  + #__ed_timeec + + + ) + +76  + ~ + +79  + ~ + +84 (* + t__sighdr_t +) (); + +89 +__sighdr_t + + $__sysv_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +90 +__THROW +; + +91 #ifde +__USE_GNU + + +92 +__sighdr_t + + $sysv_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +93 +__THROW +; + +99 +__BEGIN_NAMESPACE_STD + + +100 #ifde +__USE_BSD + + +101 +__sighdr_t + + $sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +102 +__THROW +; + +105 #ifde +__REDIRECT_NTH + + +106 +__sighdr_t + + `__REDIRECT_NTH + ( +sigl +, + +107 ( +__sig +, +__sighdr_t + +__hdr +), + +108 +__sysv_sigl +); + +110  + #sigl + +__sysv_sigl + + + ) + +113 +__END_NAMESPACE_STD + + +115 #ifde +__USE_XOPEN + + +118 +__sighdr_t + + $bsd_sigl + ( +__sig +, +__sighdr_t + +__hdr +) + +119 +__THROW +; + +125 #ifde +__USE_POSIX + + +126  + $kl + ( +__pid_t + +__pid +,  +__sig + +__THROW +; + +129 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +133  + $kg + ( +__pid_t + +__pg +,  +__sig + +__THROW +; + +136 +__BEGIN_NAMESPACE_STD + + +138  + $i + ( +__sig + +__THROW +; + +139 +__END_NAMESPACE_STD + + +141 #ifde +__USE_SVID + + +143 +__sighdr_t + + $ssigl + ( +__sig +, +__sighdr_t + +__hdr +) + +144 +__THROW +; + +145  + $gsigl + ( +__sig + +__THROW +; + +148 #i +defed + +__USE_MISC + || defed +__USE_XOPEN2K + + +150  + `psigl + ( +__sig +, +__cڡ + * +__s +); + +153 #ifde +__USE_XOPEN2K + + +155  + `psigfo + ( +__cڡ + +sigfo_t + * +__pfo +, __cڡ * +__s +); + +168  + `__sigu + ( +__sig__mask +,  +__is_sig +); + +170 #ifde +__FAVOR_BSD + + +173  + $sigu + ( +__mask + +__THROW + +__ibu_dd__ +; + +175 #ifde +__USE_XOPEN + + +176 #ifde +__GNUC__ + + +177  + $sigu + ( +__sig + + `__asm__ + ("__xpg_sigpause"); + +180  + #sigu +( +sig + + `__sigu + ((sig), 1) + + ) + +186 #ifde +__USE_BSD + + +193  + #sigmask +( +sig + + `__sigmask +(sig) + + ) + +196  + $sigblock + ( +__mask + +__THROW + +__ibu_dd__ +; + +199  + $sigtmask + ( +__mask + +__THROW + +__ibu_dd__ +; + +202  + $siggmask + ( +__THROW + +__ibu_dd__ +; + +206 #ifde +__USE_MISC + + +207  + #NSIG + +_NSIG + + + ) + +210 #ifde +__USE_GNU + + +211  +__sighdr_t + + tsighdr_t +; + +215 #ifde +__USE_BSD + + +216  +__sighdr_t + + tsig_t +; + +219 #ifde +__USE_POSIX + + +222  + $sigemyt + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +225  + $sigflt + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +228  + $sigaddt + ( +sigt_t + * +__t +,  +__signo + +__THROW + + `__nnu + ((1)); + +231  + $sigdt + ( +sigt_t + * +__t +,  +__signo + +__THROW + + `__nnu + ((1)); + +234  + $sigismemb + ( +__cڡ + +sigt_t + * +__t +,  +__signo +) + +235 +__THROW + + `__nnu + ((1)); + +237 #ifde +__USE_GNU + + +239  + $sigimyt + ( +__cڡ + +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +242  + $sigdt + ( +sigt_t + * +__t +, +__cڡ + sigt_* +__ +, + +243 +__cڡ + +sigt_t + * +__right + +__THROW + + `__nnu + ((1, 2, 3)); + +246  + $sigܣt + ( +sigt_t + * +__t +, +__cڡ + sigt_* +__ +, + +247 +__cڡ + +sigt_t + * +__right + +__THROW + + `__nnu + ((1, 2, 3)); + +252  + ~ + +255  + $sigocmask + ( +__how +, +__cڡ + +sigt_t + * +__ri + +__t +, + +256 +sigt_t + * +__ri + +__ot + +__THROW +; + +263  + $sigsud + ( +__cڡ + +sigt_t + * +__t + + `__nnu + ((1)); + +266  + $sigai + ( +__sig +, +__cڡ +  +sigai + * +__ri + +__a +, + +267  +sigai + * +__ri + +__ + +__THROW +; + +270  + $signdg + ( +sigt_t + * +__t + +__THROW + + `__nnu + ((1)); + +277  + $sigwa + ( +__cڡ + +sigt_t + * +__ri + +__t +, *__ri +__sig +) + +278 + `__nnu + ((1, 2)); + +280 #ifde +__USE_POSIX199309 + + +285  + $sigwafo + ( +__cڡ + +sigt_t + * +__ri + +__t +, + +286 +sigfo_t + * +__ri + +__fo + + `__nnu + ((1)); + +293  + $sigtimedwa + ( +__cڡ + +sigt_t + * +__ri + +__t +, + +294 +sigfo_t + * +__ri + +__fo +, + +295 +__cڡ +  +timeec + * +__ri + +__timeout +) + +296 + `__nnu + ((1)); + +300  + $sigqueue + ( +__pid_t + +__pid +,  +__sig +, +__cڡ +  +sigv + +__v +) + +301 +__THROW +; + +306 #ifde +__USE_BSD + + +310 +__cڡ + *__cڡ +_sys_sigli +[ +_NSIG +]; + +311 +__cڡ + *__cڡ +sys_sigli +[ +_NSIG +]; + +314  + ssigvec + + +316 +__sighdr_t + +sv_hdr +; + +317  +sv_mask +; + +319  +sv_ags +; + +320  + #sv_ڡack + +sv_ags + + + ) + +324  + #SV_ONSTACK + (1 << 0) + + ) + +325  + #SV_INTERRUPT + (1 << 1) + + ) + +326  + #SV_RESETHAND + (1 << 2) + + ) + +334  + $sigvec + ( +__sig +, +__cڡ +  +sigvec + * +__vec +, + +335  +sigvec + * +__ovec + +__THROW +; + +339  + ~ + +342  + $sigtu + ( +sigcڋxt + * +__s + +__THROW +; + +347 #i +defed + +__USE_BSD + || defed +__USE_XOPEN_EXTENDED + + +348  + #__ed_size_t + + + ) + +349  + ~ + +354  + $sigu + ( +__sig +,  +__u + +__THROW +; + +356  + ~ + +357 #ifde +__USE_XOPEN + + +359  + ~ + +365  + $sigack + ( +sigack + * +__ss +, sigack * +__oss +) + +366 +__THROW + +__ibu_dd__ +; + +370  + $sigtack + ( +__cڡ +  +sigtack + * +__ri + +__ss +, + +371  +sigtack + * +__ri + +__oss + +__THROW +; + +375 #ifde +__USE_XOPEN_EXTENDED + + +379  + $sighd + ( +__sig + +__THROW +; + +382  + $sigl + ( +__sig + +__THROW +; + +385  + $sigigne + ( +__sig + +__THROW +; + +388 +__sighdr_t + + $sigt + ( +__sig +, +__sighdr_t + +__di + +__THROW +; + +391 #i +defed + +__USE_POSIX199506 + || defed +__USE_UNIX98 + + +394  + ~ + +395  + ~ + +402  + $__libc_cut_sigm + ( +__THROW +; + +404  + $__libc_cut_sigmax + ( +__THROW +; + +408 +__END_DECLS + + + @/usr/include/bits/sched.h + +22 #ide +__ed_schedm + + +24 #ide +_SCHED_H + + +30  + #SCHED_OTHER + 0 + + ) + +31  + #SCHED_FIFO + 1 + + ) + +32  + #SCHED_RR + 2 + + ) + +33 #ifde +__USE_GNU + + +34  + #SCHED_BATCH + 3 + + ) + +37 #ifde +__USE_MISC + + +39  + #CSIGNAL + 0x000000f + + ) + +40  + #CLONE_VM + 0x00000100 + + ) + +41  + #CLONE_FS + 0x00000200 + + ) + +42  + #CLONE_FILES + 0x00000400 + + ) + +43  + #CLONE_SIGHAND + 0x00000800 + + ) + +44  + #CLONE_PTRACE + 0x00002000 + + ) + +45  + #CLONE_VFORK + 0x00004000 + + ) + +47  + #CLONE_PARENT + 0x00008000 + + ) + +49  + #CLONE_THREAD + 0x00010000 + + ) + +50  + #CLONE_NEWNS + 0x00020000 + + ) + +51  + #CLONE_SYSVSEM + 0x00040000 + + ) + +52  + #CLONE_SETTLS + 0x00080000 + + ) + +53  + #CLONE_PARENT_SETTID + 0x00100000 + + ) + +55  + #CLONE_CHILD_CLEARTID + 0x00200000 + + ) + +57  + #CLONE_DETACHED + 0x00400000 + + ) + +58  + #CLONE_UNTRACED + 0x00800000 + + ) + +60  + #CLONE_CHILD_SETTID + 0x01000000 + + ) + +62  + #CLONE_NEWUTS + 0x04000000 + + ) + +63  + #CLONE_NEWIPC + 0x08000000 + + ) + +64  + #CLONE_NEWUSER + 0x10000000 + + ) + +65  + #CLONE_NEWPID + 0x20000000 + + ) + +66  + #CLONE_NEWNET + 0x40000000 + + ) + +67  + #CLONE_IO + 0x80000000 + + ) + +71  + ssched_m + + +73  + m__sched_iܙy +; + +76 + g__BEGIN_DECLS + + +78 #ifde +__USE_MISC + + +80  +e + ((* +__ +(* +__g +), * +__chd_ack +, + +81  +__ags +, * +__g +, ... +__THROW +; + +84  + $unshe + ( +__ags + +__THROW +; + +87  + $sched_gu + ( +__THROW +; + +90 +__END_DECLS + + +94 #i! +defed + +__defed_schedm + \ + +95 && ( +defed + +__ed_schedm + || defed +_SCHED_H +) + +96  + #__defed_schedm + 1 + + ) + +98  + s__sched_m + + +100  +__sched_iܙy +; + +102 #unde +__ed_schedm + + +106 #i +defed + +_SCHED_H + && !defed +__u_t_t_defed + + +107  + #__u_t_t_defed + + + ) + +109  + #__CPU_SETSIZE + 1024 + + ) + +110  + #__NCPUBITS + (8 *  ( +__u_mask +)) + + ) + +113  + t__u_mask +; + +116  + #__CPUELT +( +u +((u/ +__NCPUBITS +) + + ) + +117  + #__CPUMASK +( +u +(( +__u_mask +1 << ((u% +__NCPUBITS +)) + + ) + +122 +__u_mask + +__bs +[ +__CPU_SETSIZE + / +__NCPUBITS +]; + +123 } + tu_t_t +; + +126 #i + `__GNUC_PREREQ + (2, 91) + +127  + #__CPU_ZERO_S +( +tsize +, +u +) \ + +128 d + `__but_memt + ( +u +, '\0', +tsize +); 0) + + ) + +130  + #__CPU_ZERO_S +( +tsize +, +u +) \ + +132 +size_t + +__i +; \ + +133 +size_t + +__imax + = ( +tsize +/  ( +__u_mask +); \ + +134 +__u_mask + * +__bs + = ( +u +)->__bits; \ + +135  +__i + = 0; __< +__imax +; ++__i) \ + +136 +__bs +[ +__i +] = 0; \ + +137 + } +} 0) + + ) + +139  + #__CPU_SET_S +( +u +, +tsize +, +u +) \ + +140 ( +__exnsi__ + \ + +141 ({ +size_t + +__u + = ( +u +); \ + +142 +__u + < 8 * ( +tsize +) \ + +143 ? ((( +__u_mask + *(( +u +)-> +__bs +))[ + `__CPUELT + ( +__u +)] \ + +144 | + `__CPUMASK + ( +__u +)) \ + +145 : 0; })) + + ) + +146  + #__CPU_CLR_S +( +u +, +tsize +, +u +) \ + +147 ( +__exnsi__ + \ + +148 ({ +size_t + +__u + = ( +u +); \ + +149 +__u + < 8 * ( +tsize +) \ + +150 ? ((( +__u_mask + *(( +u +)-> +__bs +))[ + `__CPUELT + ( +__u +)] \ + +151 &~ + `__CPUMASK + ( +__u +)) \ + +152 : 0; })) + + ) + +153  + #__CPU_ISSET_S +( +u +, +tsize +, +u +) \ + +154 ( +__exnsi__ + \ + +155 ({ +size_t + +__u + = ( +u +); \ + +156 +__u + < 8 * ( +tsize +) \ + +157 ? (((( +__cڡ + +__u_mask + *(( +u +)-> +__bs +))[ + `__CPUELT + ( +__u +)] \ + +158 & + `__CPUMASK + ( +__u +))) != 0 \ + +159 : 0; })) + + ) + +161  + #__CPU_COUNT_S +( +tsize +, +u +) \ + +162 + `__sched_ucou + ( +tsize +, +u +) + + ) + +164 #i +__GNUC_PREREQ + (2, 91) + +165  + #__CPU_EQUAL_S +( +tsize +, +u1 +, +u2 +) \ + +166 ( + `__but_memcmp + ( +u1 +, +u2 +, +tsize +=0) + + ) + +168  + #__CPU_EQUAL_S +( +tsize +, +u1 +, +u2 +) \ + +169 ( +__exnsi__ + \ + +170 ({ +__cڡ + +__u_mask + * +__r1 + = ( +u1 +)-> +__bs +; \ + +171 +__cڡ + +__u_mask + * +__r2 + = ( +u2 +)-> +__bs +; \ + +172 +size_t + +__imax + = ( +tsize +/  ( +__u_mask +); \ + +173 +size_t + +__i +; \ + +174  +__i + = 0; __< +__imax +; ++__i) \ + +175 i( +__bs +[ +__i +] != __bits[__i]) \ + +177 +__i + = +__imax +; })) + + ) + +180  + #__CPU_OP_S +( +tsize +, +det +, +ct1 +, +ct2 +, + +) \ + +181 ( +__exnsi__ + \ + +182 ({ +u_t_t + * +__de + = ( +det +); \ + +183 +__cڡ + +__u_mask + * +__r1 + = ( +ct1 +)-> +__bs +; \ + +184 +__cڡ + +__u_mask + * +__r2 + = ( +ct2 +)-> +__bs +; \ + +185 +size_t + +__imax + = ( +tsize +/  ( +__u_mask +); \ + +186 +size_t + +__i +; \ + +187  +__i + = 0; __< +__imax +; ++__i) \ + +188 (( +__u_mask + * +__de +-> +__bs +)[ +__i +] = +__r1 +[__i] + + +__r2 +[__i]; \ + +189 +__de +; })) + + ) + +191  + #__CPU_ALLOC_SIZE +( +cou +) \ + +192 (((( +cou ++ +__NCPUBITS + - 1/ __NCPUBITS*  ( +__u_mask +)) + + ) + +193  + #__CPU_ALLOC +( +cou + + `__sched_uloc + (cou) + + ) + +194  + #__CPU_FREE +( +ut + + `__sched_u + (ut) + + ) + +196 +__BEGIN_DECLS + + +198  + $__sched_ucou + ( +size_t + +__tsize +, cڡ +u_t_t + * +__ +) + +199 +__THROW +; + +200 +u_t_t + * + $__sched_uloc + ( +size_t + +__cou + +__THROW + +__wur +; + +201  + $__sched_u + ( +u_t_t + * +__t + +__THROW +; + +203 +__END_DECLS + + + @/usr/include/bits/sigaction.h + +20 #ide +_SIGNAL_H + + +25  + ssigai + + +28 #ifde +__USE_POSIX199309 + + +32 +__sighdr_t + + m_hdr +; + +34 (* + m_sigai +(, + msigfo_t + *, *); + +36 + m__sigai_hdr +; + +37  + #_hdr + +__sigai_hdr +. +_hdr + + + ) + +38  + #_sigai + +__sigai_hdr +. +_sigai + + + ) + +40 +__sighdr_t + + m_hdr +; + +44 +__sigt_t + + m_mask +; + +47  + m_ags +; + +50 (* + m_ܔ +) (); + +54  + #SA_NOCLDSTOP + 1 + + ) + +55  + #SA_NOCLDWAIT + 2 + + ) + +56  + #SA_SIGINFO + 4 + + ) + +58 #i +defed + +__USE_UNIX98 + || defed +__USE_MISC + + +59  + #SA_ONSTACK + 0x08000000 + + ) + +60  + #SA_RESTART + 0x10000000 + + ) + +61  + #SA_NODEFER + 0x40000000 + + ) + +63  + #SA_RESETHAND + 0x80000000 + + ) + +65 #ifde +__USE_MISC + + +66  + #SA_INTERRUPT + 0x20000000 + + ) + +69  + #SA_NOMASK + +SA_NODEFER + + + ) + +70  + #SA_ONESHOT + +SA_RESETHAND + + + ) + +71  + #SA_STACK + +SA_ONSTACK + + + ) + +75  + #SIG_BLOCK + 0 + + ) + +76  + #SIG_UNBLOCK + 1 + + ) + +77  + #SIG_SETMASK + 2 + + ) + + @/usr/include/bits/sigcontext.h + +19 #ide +_BITS_SIGCONTEXT_H + + +20  + #_BITS_SIGCONTEXT_H + 1 + + ) + +22 #i! +defed + +_SIGNAL_H + && !defed +_SYS_UCONTEXT_H + + +26  + ~ + +28  + s_g + + +30  + msignifind +[4]; + +31  + mexpڒt +; + +34  + s_xg + + +36  + msignifind +[4]; + +37  + mexpڒt +; + +38  + mddg +[3]; + +41  + s_xmmg + + +43 +__ut32_t + + memt +[4]; + +48 #i +__WORDSIZE + == 32 + +50  + s_塩e + + +53 +__ut32_t + + mcw +; + +54 +__ut32_t + + msw +; + +55 +__ut32_t + + mg +; + +56 +__ut32_t + + moff +; + +57 +__ut32_t + + mcsl +; + +58 +__ut32_t + + mdaoff +; + +59 +__ut32_t + + mdal +; + +60  +_g + + m_ +[8]; + +61  + mus +; + +62  + mmagic +; + +65 +__ut32_t + + m_fx_v +[6]; + +66 +__ut32_t + + mmxc +; + +67 +__ut32_t + + mrved +; + +68  +_xg + + m_fx_ +[8]; + +69  +_xmmg + + m_xmm +[8]; + +70 +__ut32_t + + mddg +[56]; + +73 #ide +sigcڋxt_ru + + +78  + #sigcڋxt_ru + +sigcڋxt + + + ) + +81  + ssigcڋxt + + +83  + mgs +, + m__gsh +; + +84  + mfs +, + m__fsh +; + +85  + mes +, + m__esh +; + +86  + mds +, + m__dsh +; + +87  + medi +; + +88  + mesi +; + +89  + mebp +; + +90  + me +; + +91  + mebx +; + +92  + medx +; + +93  + mecx +; + +94  + mx +; + +95  + mno +; + +96  + mr +; + +97  + me +; + +98  + mcs +, + m__csh +; + +99  + meags +; + +100  + me__sigl +; + +101  + mss +, + m__ssh +; + +102  +_塩e + * + m塩e +; + +103  + mdmask +; + +104  + m2 +; + +109  + s_塩e + + +112 +__ut16_t + + mcwd +; + +113 +__ut16_t + + mswd +; + +114 +__ut16_t + + mw +; + +115 +__ut16_t + + mf +; + +116 +__ut64_t + + mr +; + +117 +__ut64_t + + mrdp +; + +118 +__ut32_t + + mmxc +; + +119 +__ut32_t + + mmx_mask +; + +120  +_xg + + m_ +[8]; + +121  +_xmmg + + m_xmm +[16]; + +122 +__ut32_t + + mddg +[24]; + +125  + ssigcڋxt + + +127  + mr8 +; + +128  + mr9 +; + +129  + mr10 +; + +130  + mr11 +; + +131  + mr12 +; + +132  + mr13 +; + +133  + mr14 +; + +134  + mr15 +; + +135  + mrdi +; + +136  + mrsi +; + +137  + mrbp +; + +138  + mrbx +; + +139  + mrdx +; + +140  + mx +; + +141  + mrcx +; + +142  + mr +; + +143  + mr +; + +144  + meags +; + +145  + mcs +; + +146  + mgs +; + +147  + mfs +; + +148  + m__d0 +; + +149  + mr +; + +150  + mno +; + +151  + mdmask +; + +152  + m2 +; + +153  +_塩e + * + m塩e +; + +154  + m__rved1 + [8]; + + @/usr/include/bits/siginfo.h + +20 #i! +defed + +_SIGNAL_H + && !defed +__ed_sigfo_t + \ + +21 && ! +defed + + g__ed_sigevt_t + + +25  + ~ + +27 #i(! +defed + +__have_sigv_t + \ + +28 && ( +defed + + g_SIGNAL_H + || defed + g__ed_sigfo_t + \ + +29 || +defed + + g__ed_sigevt_t +)) + +30  + #__have_sigv_t + 1 + + ) + +33  + usigv + + +35  + msiv_t +; + +36 * + msiv_r +; + +37 } + tsigv_t +; + +40 #i(! +defed + +__have_sigfo_t + \ + +41 && ( +defed + + g_SIGNAL_H + || defed + g__ed_sigfo_t +)) + +42  + #__have_sigfo_t + 1 + + ) + +44  + #__SI_MAX_SIZE + 128 + + ) + +45 #i +__WORDSIZE + == 64 + +46  + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + /  ()- 4) + + ) + +48  + #__SI_PAD_SIZE + (( +__SI_MAX_SIZE + /  ()- 3) + + ) + +51  + ssigfo + + +53  + msi_signo +; + +54  + msi_o +; + +56  + msi_code +; + +60  + m_d +[ +__SI_PAD_SIZE +]; + +65 +__pid_t + + msi_pid +; + +66 +__uid_t + + msi_uid +; + +67 } + m_kl +; + +72  + msi_tid +; + +73  + msi_ovrun +; + +74 +sigv_t + + msi_sigv +; + +75 } + m_tim +; + +80 +__pid_t + + msi_pid +; + +81 +__uid_t + + msi_uid +; + +82 +sigv_t + + msi_sigv +; + +83 } + m_ +; + +88 +__pid_t + + msi_pid +; + +89 +__uid_t + + msi_uid +; + +90  + msi_us +; + +91 +__ock_t + + msi_utime +; + +92 +__ock_t + + msi_ime +; + +93 } + m_sigchld +; + +98 * + msi_addr +; + +99 } + m_sigu +; + +104  + msi_bd +; + +105  + msi_fd +; + +106 } + m_sigpl +; + +107 } + m_siflds +; + +108 } + tsigfo_t +; + +112  + #si_pid + +_siflds +. +_kl +. +si_pid + + + ) + +113  + #si_uid + +_siflds +. +_kl +. +si_uid + + + ) + +114  + #si_timid + +_siflds +. +_tim +. +si_tid + + + ) + +115  + #si_ovrun + +_siflds +. +_tim +. +si_ovrun + + + ) + +116  + #si_us + +_siflds +. +_sigchld +. +si_us + + + ) + +117  + #si_utime + +_siflds +. +_sigchld +. +si_utime + + + ) + +118  + #si_ime + +_siflds +. +_sigchld +. +si_ime + + + ) + +119  + #si_vue + +_siflds +. +_ +. +si_sigv + + + ) + +120  + #si_t + +_siflds +. +_ +. +si_sigv +. +siv_t + + + ) + +121  + #si_r + +_siflds +. +_ +. +si_sigv +. +siv_r + + + ) + +122  + #si_addr + +_siflds +. +_sigu +. +si_addr + + + ) + +123  + #si_bd + +_siflds +. +_sigpl +. +si_bd + + + ) + +124  + #si_fd + +_siflds +. +_sigpl +. +si_fd + + + ) + +131 + mSI_ASYNCNL + = -60, + +132  + #SI_ASYNCNL + +SI_ASYNCNL + + + ) + +133 + mSI_TKILL + = -6, + +134  + #SI_TKILL + +SI_TKILL + + + ) + +135 + mSI_SIGIO +, + +136  + #SI_SIGIO + +SI_SIGIO + + + ) + +137 + mSI_ASYNCIO +, + +138  + #SI_ASYNCIO + +SI_ASYNCIO + + + ) + +139 + mSI_MESGQ +, + +140  + #SI_MESGQ + +SI_MESGQ + + + ) + +141 + mSI_TIMER +, + +142  + #SI_TIMER + +SI_TIMER + + + ) + +143 + mSI_QUEUE +, + +144  + #SI_QUEUE + +SI_QUEUE + + + ) + +145 + mSI_USER +, + +146  + #SI_USER + +SI_USER + + + ) + +147 + mSI_KERNEL + = 0x80 + +148  + #SI_KERNEL + +SI_KERNEL + + + ) + +155 + mILL_ILLOPC + = 1, + +156  + #ILL_ILLOPC + +ILL_ILLOPC + + + ) + +157 + mILL_ILLOPN +, + +158  + #ILL_ILLOPN + +ILL_ILLOPN + + + ) + +159 + mILL_ILLADR +, + +160  + #ILL_ILLADR + +ILL_ILLADR + + + ) + +161 + mILL_ILLTRP +, + +162  + #ILL_ILLTRP + +ILL_ILLTRP + + + ) + +163 + mILL_PRVOPC +, + +164  + #ILL_PRVOPC + +ILL_PRVOPC + + + ) + +165 + mILL_PRVREG +, + +166  + #ILL_PRVREG + +ILL_PRVREG + + + ) + +167 + mILL_COPROC +, + +168  + #ILL_COPROC + +ILL_COPROC + + + ) + +169 + mILL_BADSTK + + +170  + #ILL_BADSTK + +ILL_BADSTK + + + ) + +176 + mFPE_INTDIV + = 1, + +177  + #FPE_INTDIV + +FPE_INTDIV + + + ) + +178 + mFPE_INTOVF +, + +179  + #FPE_INTOVF + +FPE_INTOVF + + + ) + +180 + mFPE_FLTDIV +, + +181  + #FPE_FLTDIV + +FPE_FLTDIV + + + ) + +182 + mFPE_FLTOVF +, + +183  + #FPE_FLTOVF + +FPE_FLTOVF + + + ) + +184 + mFPE_FLTUND +, + +185  + #FPE_FLTUND + +FPE_FLTUND + + + ) + +186 + mFPE_FLTRES +, + +187  + #FPE_FLTRES + +FPE_FLTRES + + + ) + +188 + mFPE_FLTINV +, + +189  + #FPE_FLTINV + +FPE_FLTINV + + + ) + +190 + mFPE_FLTSUB + + +191  + #FPE_FLTSUB + +FPE_FLTSUB + + + ) + +197 + mSEGV_MAPERR + = 1, + +198  + #SEGV_MAPERR + +SEGV_MAPERR + + + ) + +199 + mSEGV_ACCERR + + +200  + #SEGV_ACCERR + +SEGV_ACCERR + + + ) + +206 + mBUS_ADRALN + = 1, + +207  + #BUS_ADRALN + +BUS_ADRALN + + + ) + +208 + mBUS_ADRERR +, + +209  + #BUS_ADRERR + +BUS_ADRERR + + + ) + +210 + mBUS_OBJERR + + +211  + #BUS_OBJERR + +BUS_OBJERR + + + ) + +217 + mTRAP_BRKPT + = 1, + +218  + #TRAP_BRKPT + +TRAP_BRKPT + + + ) + +219 + mTRAP_TRACE + + +220  + #TRAP_TRACE + +TRAP_TRACE + + + ) + +226 + mCLD_EXITED + = 1, + +227  + #CLD_EXITED + +CLD_EXITED + + + ) + +228 + mCLD_KILLED +, + +229  + #CLD_KILLED + +CLD_KILLED + + + ) + +230 + mCLD_DUMPED +, + +231  + #CLD_DUMPED + +CLD_DUMPED + + + ) + +232 + mCLD_TRAPPED +, + +233  + #CLD_TRAPPED + +CLD_TRAPPED + + + ) + +234 + mCLD_STOPPED +, + +235  + #CLD_STOPPED + +CLD_STOPPED + + + ) + +236 + mCLD_CONTINUED + + +237  + #CLD_CONTINUED + +CLD_CONTINUED + + + ) + +243 + mPOLL_IN + = 1, + +244  + #POLL_IN + +POLL_IN + + + ) + +245 + mPOLL_OUT +, + +246  + #POLL_OUT + +POLL_OUT + + + ) + +247 + mPOLL_MSG +, + +248  + #POLL_MSG + +POLL_MSG + + + ) + +249 + mPOLL_ERR +, + +250  + #POLL_ERR + +POLL_ERR + + + ) + +251 + mPOLL_PRI +, + +252  + #POLL_PRI + +POLL_PRI + + + ) + +253 + mPOLL_HUP + + +254  + #POLL_HUP + +POLL_HUP + + + ) + +257 #unde +__ed_sigfo_t + + +261 #i( +defed + +_SIGNAL_H + || defed +__ed_sigevt_t +) \ + +262 && ! +defed + + g__have_sigevt_t + + +263  + #__have_sigevt_t + 1 + + ) + +266  + #__SIGEV_MAX_SIZE + 64 + + ) + +267 #i +__WORDSIZE + == 64 + +268  + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + /  ()- 4) + + ) + +270  + #__SIGEV_PAD_SIZE + (( +__SIGEV_MAX_SIZE + /  ()- 3) + + ) + +273  + ssigevt + + +275 +sigv_t + + msigev_vue +; + +276  + msigev_signo +; + +277  + msigev_nify +; + +281  + m_d +[ +__SIGEV_PAD_SIZE +]; + +285 +__pid_t + + m_tid +; + +289 (* + m_funi +( + msigv_t +); + +290 * + m_ibu +; + +291 } + m_sigev_thad +; + +292 } + m_sigev_un +; + +293 } + tsigevt_t +; + +296  + #sigev_nify_funi + +_sigev_un +. +_sigev_thad +. +_funi + + + ) + +297  + #sigev_nify_ibus + +_sigev_un +. +_sigev_thad +. +_ibu + + + ) + +302 + mSIGEV_SIGNAL + = 0, + +303  + #SIGEV_SIGNAL + +SIGEV_SIGNAL + + + ) + +304 + mSIGEV_NONE +, + +305  + #SIGEV_NONE + +SIGEV_NONE + + + ) + +306 + mSIGEV_THREAD +, + +307  + #SIGEV_THREAD + +SIGEV_THREAD + + + ) + +309 + mSIGEV_THREAD_ID + = 4 + +310  + #SIGEV_THREAD_ID + +SIGEV_THREAD_ID + + + ) + + @/usr/include/bits/signum.h + +20 #ifdef +_SIGNAL_H + + +23  + #SIG_ERR + (( +__sighdr_t +-1 + + ) + +24  + #SIG_DFL + (( +__sighdr_t +0 + + ) + +25  + #SIG_IGN + (( +__sighdr_t +1 + + ) + +27 #ifde +__USE_UNIX98 + + +28  + #SIG_HOLD + (( +__sighdr_t +2 + + ) + +33  + #SIGHUP + 1 + + ) + +34  + #SIGINT + 2 + + ) + +35  + #SIGQUIT + 3 + + ) + +36  + #SIGILL + 4 + + ) + +37  + #SIGTRAP + 5 + + ) + +38  + #SIGABRT + 6 + + ) + +39  + #SIGIOT + 6 + + ) + +40  + #SIGBUS + 7 + + ) + +41  + #SIGFPE + 8 + + ) + +42  + #SIGKILL + 9 + + ) + +43  + #SIGUSR1 + 10 + + ) + +44  + #SIGSEGV + 11 + + ) + +45  + #SIGUSR2 + 12 + + ) + +46  + #SIGPIPE + 13 + + ) + +47  + #SIGALRM + 14 + + ) + +48  + #SIGTERM + 15 + + ) + +49  + #SIGSTKFLT + 16 + + ) + +50  + #SIGCLD + +SIGCHLD + + + ) + +51  + #SIGCHLD + 17 + + ) + +52  + #SIGCONT + 18 + + ) + +53  + #SIGSTOP + 19 + + ) + +54  + #SIGTSTP + 20 + + ) + +55  + #SIGTTIN + 21 + + ) + +56  + #SIGTTOU + 22 + + ) + +57  + #SIGURG + 23 + + ) + +58  + #SIGXCPU + 24 + + ) + +59  + #SIGXFSZ + 25 + + ) + +60  + #SIGVTALRM + 26 + + ) + +61  + #SIGPROF + 27 + + ) + +62  + #SIGWINCH + 28 + + ) + +63  + #SIGPOLL + +SIGIO + + + ) + +64  + #SIGIO + 29 + + ) + +65  + #SIGPWR + 30 + + ) + +66  + #SIGSYS + 31 + + ) + +67  + #SIGUNUSED + 31 + + ) + +69  + #_NSIG + 65 + + ) + +72  + #SIGRTMIN + ( + `__libc_cut_sigm + ()) + + ) + +73  + #SIGRTMAX + ( + `__libc_cut_sigmax + ()) + + ) + +77  + #__SIGRTMIN + 32 + + ) + +78  + #__SIGRTMAX + ( +_NSIG + - 1) + + ) + + @/usr/include/bits/sigstack.h + +20 #ide +_SIGNAL_H + + +26  + ssigack + + +28 * + mss_ +; + +29  + mss_ڡack +; + +36 + mSS_ONSTACK + = 1, + +37  + #SS_ONSTACK + +SS_ONSTACK + + + ) + +38 + mSS_DISABLE + + +39  + #SS_DISABLE + +SS_DISABLE + + + ) + +43  + #MINSIGSTKSZ + 2048 + + ) + +46  + #SIGSTKSZ + 8192 + + ) + +50  + ssigtack + + +52 * + mss_ +; + +53  + mss_ags +; + +54 +size_t + + mss_size +; + +55 } + tack_t +; + + @/usr/include/bits/sigthread.h + +20 #ide +_BITS_SIGTHREAD_H + + +21  + #_BITS_SIGTHREAD_H + 1 + + ) + +23 #i! +defed + +_SIGNAL_H + && !defed +_PTHREAD_H + + +31  + $had_sigmask + ( +__how +, + +32 +__cڡ + +__sigt_t + * +__ri + +__wmask +, + +33 +__sigt_t + * +__ri + +__dmask +) +__THROW +; + +36  + $had_kl + ( +had_t + +__thadid +,  +__signo + +__THROW +; + +38 #ifde +__USE_GNU + + +40  + $had_sigqueue + ( +had_t + +__thadid +,  +__signo +, + +41 cڡ  +sigv + +__vue + +__THROW +; + + @/usr/include/linux/errno.h + +1 #ide +_LINUX_ERRNO_H + + +2  + #_LINUX_ERRNO_H + + + ) + +4  + ~ + + @/usr/include/sys/ucontext.h + +19 #ide +_SYS_UCONTEXT_H + + +20  + #_SYS_UCONTEXT_H + 1 + + ) + +22  + ~ + +23  + ~ + +24  + ~ + +28  + ~ + +30 #i +__WORDSIZE + == 64 + +33  + tgg_t +; + +36  + #NGREG + 23 + + ) + +39  +gg_t + + tggt_t +[ +NGREG +]; + +41 #ifde +__USE_GNU + + +45 + mREG_R8 + = 0, + +46  + #REG_R8 + +REG_R8 + + + ) + +47 + mREG_R9 +, + +48  + #REG_R9 + +REG_R9 + + + ) + +49 + mREG_R10 +, + +50  + #REG_R10 + +REG_R10 + + + ) + +51 + mREG_R11 +, + +52  + #REG_R11 + +REG_R11 + + + ) + +53 + mREG_R12 +, + +54  + #REG_R12 + +REG_R12 + + + ) + +55 + mREG_R13 +, + +56  + #REG_R13 + +REG_R13 + + + ) + +57 + mREG_R14 +, + +58  + #REG_R14 + +REG_R14 + + + ) + +59 + mREG_R15 +, + +60  + #REG_R15 + +REG_R15 + + + ) + +61 + mREG_RDI +, + +62  + #REG_RDI + +REG_RDI + + + ) + +63 + mREG_RSI +, + +64  + #REG_RSI + +REG_RSI + + + ) + +65 + mREG_RBP +, + +66  + #REG_RBP + +REG_RBP + + + ) + +67 + mREG_RBX +, + +68  + #REG_RBX + +REG_RBX + + + ) + +69 + mREG_RDX +, + +70  + #REG_RDX + +REG_RDX + + + ) + +71 + mREG_RAX +, + +72  + #REG_RAX + +REG_RAX + + + ) + +73 + mREG_RCX +, + +74  + #REG_RCX + +REG_RCX + + + ) + +75 + mREG_RSP +, + +76  + #REG_RSP + +REG_RSP + + + ) + +77 + mREG_RIP +, + +78  + #REG_RIP + +REG_RIP + + + ) + +79 + mREG_EFL +, + +80  + #REG_EFL + +REG_EFL + + + ) + +81 + mREG_CSGSFS +, + +82  + #REG_CSGSFS + +REG_CSGSFS + + + ) + +83 + mREG_ERR +, + +84  + #REG_ERR + +REG_ERR + + + ) + +85 + mREG_TRAPNO +, + +86  + #REG_TRAPNO + +REG_TRAPNO + + + ) + +87 + mREG_OLDMASK +, + +88  + #REG_OLDMASK + +REG_OLDMASK + + + ) + +89 + mREG_CR2 + + +90  + #REG_CR2 + +REG_CR2 + + + ) + +94  + s_libc_xg + + +96  + msignifind +[4]; + +97  + mexpڒt +; + +98  + mddg +[3]; + +101  + s_libc_xmmg + + +103 +__ut32_t + + memt +[4]; + +106  + s_libc_塩e + + +109 +__ut16_t + + mcwd +; + +110 +__ut16_t + + mswd +; + +111 +__ut16_t + + mw +; + +112 +__ut16_t + + mf +; + +113 +__ut64_t + + mr +; + +114 +__ut64_t + + mrdp +; + +115 +__ut32_t + + mmxc +; + +116 +__ut32_t + + mmx_mask +; + +117  +_libc_xg + + m_ +[8]; + +118  +_libc_xmmg + + m_xmm +[16]; + +119 +__ut32_t + + mddg +[24]; + +123  +_libc_塩e + * + tgt_t +; + +128 +ggt_t + + mggs +; + +130 +gt_t + + mgs +; + +131  + m__rved1 + [8]; + +132 } + tmcڋxt_t +; + +135  + sucڋxt + + +137  + muc_ags +; + +138  +ucڋxt + * + muc_lk +; + +139 +ack_t + + muc_ack +; + +140 +mcڋxt_t + + muc_mcڋxt +; + +141 +__sigt_t + + muc_sigmask +; + +142  +_libc_塩e + + m__gs_mem +; + +143 } + tucڋxt_t +; + +148  + tgg_t +; + +151  + #NGREG + 19 + + ) + +154  +gg_t + + tggt_t +[ +NGREG +]; + +156 #ifde +__USE_GNU + + +160 + mREG_GS + = 0, + +161  + #REG_GS + +REG_GS + + + ) + +162 + mREG_FS +, + +163  + #REG_FS + +REG_FS + + + ) + +164 + mREG_ES +, + +165  + #REG_ES + +REG_ES + + + ) + +166 + mREG_DS +, + +167  + #REG_DS + +REG_DS + + + ) + +168 + mREG_EDI +, + +169  + #REG_EDI + +REG_EDI + + + ) + +170 + mREG_ESI +, + +171  + #REG_ESI + +REG_ESI + + + ) + +172 + mREG_EBP +, + +173  + #REG_EBP + +REG_EBP + + + ) + +174 + mREG_ESP +, + +175  + #REG_ESP + +REG_ESP + + + ) + +176 + mREG_EBX +, + +177  + #REG_EBX + +REG_EBX + + + ) + +178 + mREG_EDX +, + +179  + #REG_EDX + +REG_EDX + + + ) + +180 + mREG_ECX +, + +181  + #REG_ECX + +REG_ECX + + + ) + +182 + mREG_EAX +, + +183  + #REG_EAX + +REG_EAX + + + ) + +184 + mREG_TRAPNO +, + +185  + #REG_TRAPNO + +REG_TRAPNO + + + ) + +186 + mREG_ERR +, + +187  + #REG_ERR + +REG_ERR + + + ) + +188 + mREG_EIP +, + +189  + #REG_EIP + +REG_EIP + + + ) + +190 + mREG_CS +, + +191  + #REG_CS + +REG_CS + + + ) + +192 + mREG_EFL +, + +193  + #REG_EFL + +REG_EFL + + + ) + +194 + mREG_UESP +, + +195  + #REG_UESP + +REG_UESP + + + ) + +196 + mREG_SS + + +197  + #REG_SS + +REG_SS + + + ) + +202  + s_libc_g + + +204  + msignifind +[4]; + +205  + mexpڒt +; + +208  + s_libc_塩e + + +210  + mcw +; + +211  + msw +; + +212  + mg +; + +213  + moff +; + +214  + mcsl +; + +215  + mdaoff +; + +216  + mdal +; + +217  +_libc_g + + m_ +[8]; + +218  + mus +; + +222  +_libc_塩e + * + tgt_t +; + +227 +ggt_t + + mggs +; + +230 +gt_t + + mgs +; + +231  + mdmask +; + +232  + m2 +; + +233 } + tmcڋxt_t +; + +236  + sucڋxt + + +238  + muc_ags +; + +239  +ucڋxt + * + muc_lk +; + +240 +ack_t + + muc_ack +; + +241 +mcڋxt_t + + muc_mcڋxt +; + +242 +__sigt_t + + muc_sigmask +; + +243  +_libc_塩e + + m__gs_mem +; + +244 } + tucڋxt_t +; + + @/usr/include/asm/errno.h + +1  + ~ + + @/usr/include/asm-generic/errno.h + +1 #ide +_ASM_GENERIC_ERRNO_H + + +2  + #_ASM_GENERIC_ERRNO_H + + + ) + +4  + ~ + +6  + #EDEADLK + 35 + + ) + +7  + #ENAMETOOLONG + 36 + + ) + +8  + #ENOLCK + 37 + + ) + +9  + #ENOSYS + 38 + + ) + +10  + #ENOTEMPTY + 39 + + ) + +11  + #ELOOP + 40 + + ) + +12  + #EWOULDBLOCK + +EAGAIN + + + ) + +13  + #ENOMSG + 42 + + ) + +14  + #EIDRM + 43 + + ) + +15  + #ECHRNG + 44 + + ) + +16  + #EL2NSYNC + 45 + + ) + +17  + #EL3HLT + 46 + + ) + +18  + #EL3RST + 47 + + ) + +19  + #ELNRNG + 48 + + ) + +20  + #EUNATCH + 49 + + ) + +21  + #ENOCSI + 50 + + ) + +22  + #EL2HLT + 51 + + ) + +23  + #EBADE + 52 + + ) + +24  + #EBADR + 53 + + ) + +25  + #EXFULL + 54 + + ) + +26  + #ENOANO + 55 + + ) + +27  + #EBADRQC + 56 + + ) + +28  + #EBADSLT + 57 + + ) + +30  + #EDEADLOCK + +EDEADLK + + + ) + +32  + #EBFONT + 59 + + ) + +33  + #ENOSTR + 60 + + ) + +34  + #ENODATA + 61 + + ) + +35  + #ETIME + 62 + + ) + +36  + #ENOSR + 63 + + ) + +37  + #ENONET + 64 + + ) + +38  + #ENOPKG + 65 + + ) + +39  + #EREMOTE + 66 + + ) + +40  + #ENOLINK + 67 + + ) + +41  + #EADV + 68 + + ) + +42  + #ESRMNT + 69 + + ) + +43  + #ECOMM + 70 + + ) + +44  + #EPROTO + 71 + + ) + +45  + #EMULTIHOP + 72 + + ) + +46  + #EDOTDOT + 73 + + ) + +47  + #EBADMSG + 74 + + ) + +48  + #EOVERFLOW + 75 + + ) + +49  + #ENOTUNIQ + 76 + + ) + +50  + #EBADFD + 77 + + ) + +51  + #EREMCHG + 78 + + ) + +52  + #ELIBACC + 79 + + ) + +53  + #ELIBBAD + 80 + + ) + +54  + #ELIBSCN + 81 + + ) + +55  + #ELIBMAX + 82 + + ) + +56  + #ELIBEXEC + 83 + + ) + +57  + #EILSEQ + 84 + + ) + +58  + #ERESTART + 85 + + ) + +59  + #ESTRPIPE + 86 + + ) + +60  + #EUSERS + 87 + + ) + +61  + #ENOTSOCK + 88 + + ) + +62  + #EDESTADDRREQ + 89 + + ) + +63  + #EMSGSIZE + 90 + + ) + +64  + #EPROTOTYPE + 91 + + ) + +65  + #ENOPROTOOPT + 92 + + ) + +66  + #EPROTONOSUPPORT + 93 + + ) + +67  + #ESOCKTNOSUPPORT + 94 + + ) + +68  + #EOPNOTSUPP + 95 + + ) + +69  + #EPFNOSUPPORT + 96 + + ) + +70  + #EAFNOSUPPORT + 97 + + ) + +71  + #EADDRINUSE + 98 + + ) + +72  + #EADDRNOTAVAIL + 99 + + ) + +73  + #ENETDOWN + 100 + + ) + +74  + #ENETUNREACH + 101 + + ) + +75  + #ENETRESET + 102 + + ) + +76  + #ECONNABORTED + 103 + + ) + +77  + #ECONNRESET + 104 + + ) + +78  + #ENOBUFS + 105 + + ) + +79  + #EISCONN + 106 + + ) + +80  + #ENOTCONN + 107 + + ) + +81  + #ESHUTDOWN + 108 + + ) + +82  + #ETOOMANYREFS + 109 + + ) + +83  + #ETIMEDOUT + 110 + + ) + +84  + #ECONNREFUSED + 111 + + ) + +85  + #EHOSTDOWN + 112 + + ) + +86  + #EHOSTUNREACH + 113 + + ) + +87  + #EALREADY + 114 + + ) + +88  + #EINPROGRESS + 115 + + ) + +89  + #ESTALE + 116 + + ) + +90  + #EUCLEAN + 117 + + ) + +91  + #ENOTNAM + 118 + + ) + +92  + #ENAVAIL + 119 + + ) + +93  + #EISNAM + 120 + + ) + +94  + #EREMOTEIO + 121 + + ) + +95  + #EDQUOT + 122 + + ) + +97  + #ENOMEDIUM + 123 + + ) + +98  + #EMEDIUMTYPE + 124 + + ) + +99  + #ECANCELED + 125 + + ) + +100  + #ENOKEY + 126 + + ) + +101  + #EKEYEXPIRED + 127 + + ) + +102  + #EKEYREVOKED + 128 + + ) + +103  + #EKEYREJECTED + 129 + + ) + +106  + #EOWNERDEAD + 130 + + ) + +107  + #ENOTRECOVERABLE + 131 + + ) + +109  + #ERFKILL + 132 + + ) + + @/usr/include/asm-generic/errno-base.h + +1 #ide +_ASM_GENERIC_ERRNO_BASE_H + + +2  + #_ASM_GENERIC_ERRNO_BASE_H + + + ) + +4  + #EPERM + 1 + + ) + +5  + #ENOENT + 2 + + ) + +6  + #ESRCH + 3 + + ) + +7  + #EINTR + 4 + + ) + +8  + #EIO + 5 + + ) + +9  + #ENXIO + 6 + + ) + +10  + #E2BIG + 7 + + ) + +11  + #ENOEXEC + 8 + + ) + +12  + #EBADF + 9 + + ) + +13  + #ECHILD + 10 + + ) + +14  + #EAGAIN + 11 + + ) + +15  + #ENOMEM + 12 + + ) + +16  + #EACCES + 13 + + ) + +17  + #EFAULT + 14 + + ) + +18  + #ENOTBLK + 15 + + ) + +19  + #EBUSY + 16 + + ) + +20  + #EEXIST + 17 + + ) + +21  + #EXDEV + 18 + + ) + +22  + #ENODEV + 19 + + ) + +23  + #ENOTDIR + 20 + + ) + +24  + #EISDIR + 21 + + ) + +25  + #EINVAL + 22 + + ) + +26  + #ENFILE + 23 + + ) + +27  + #EMFILE + 24 + + ) + +28  + #ENOTTY + 25 + + ) + +29  + #ETXTBSY + 26 + + ) + +30  + #EFBIG + 27 + + ) + +31  + #ENOSPC + 28 + + ) + +32  + #ESPIPE + 29 + + ) + +33  + #EROFS + 30 + + ) + +34  + #EMLINK + 31 + + ) + +35  + #EPIPE + 32 + + ) + +36  + #EDOM + 33 + + ) + +37  + #ERANGE + 34 + + ) + + @ +1 +. +1 +/usr/include +87 +2228 +CG.cc +CG_roseBuilder.cc +CG_roseRepr.cc +CG_stringBuilder.cc +CG_stringRepr.cc +CG_suifBuilder.cc +CG_suifRepr.cc +code_gen.cc +output_repr.cc +/usr/include/math.h +/usr/include/stdio.h +/usr/include/string.h +/usr/include/bits/huge_val.h +/usr/include/bits/huge_valf.h +/usr/include/bits/huge_vall.h +/usr/include/bits/inf.h +/usr/include/bits/mathcalls.h +/usr/include/bits/mathdef.h +/usr/include/bits/mathinline.h +/usr/include/bits/nan.h +/usr/include/bits/stdio-ldbl.h +/usr/include/bits/stdio.h +/usr/include/bits/stdio2.h +/usr/include/bits/stdio_lim.h +/usr/include/bits/string.h +/usr/include/bits/string2.h +/usr/include/bits/string3.h +/usr/include/bits/sys_errlist.h +/usr/include/bits/types.h +/usr/include/features.h +/usr/include/getopt.h +/usr/include/libio.h +/usr/include/xlocale.h +/usr/include/_G_config.h +/usr/include/bits/libio-ldbl.h +/usr/include/bits/predefs.h +/usr/include/bits/stdio-lock.h +/usr/include/bits/typesizes.h +/usr/include/bits/wordsize.h +/usr/include/ctype.h +/usr/include/endian.h +/usr/include/gnu/stubs.h +/usr/include/stdlib.h +/usr/include/sys/cdefs.h +/usr/include/alloca.h +/usr/include/bits/byteswap.h +/usr/include/bits/endian.h +/usr/include/bits/libc-lock.h +/usr/include/bits/stdlib-ldbl.h +/usr/include/bits/stdlib.h +/usr/include/bits/waitflags.h +/usr/include/bits/waitstatus.h +/usr/include/gconv.h +/usr/include/gnu/stubs-32.h +/usr/include/gnu/stubs-64.h +/usr/include/sys/types.h +/usr/include/wchar.h +/usr/include/bits/pthreadtypes.h +/usr/include/bits/wchar-ldbl.h +/usr/include/bits/wchar.h +/usr/include/bits/wchar2.h +/usr/include/errno.h +/usr/include/gnu/option-groups.h +/usr/include/pthread.h +/usr/include/sys/select.h +/usr/include/sys/sysmacros.h +/usr/include/time.h +/usr/include/wctype.h +/usr/include/bits/errno.h +/usr/include/bits/select.h +/usr/include/bits/setjmp.h +/usr/include/bits/sigset.h +/usr/include/bits/time.h +/usr/include/sched.h +/usr/include/signal.h +/usr/include/bits/sched.h +/usr/include/bits/sigaction.h +/usr/include/bits/sigcontext.h +/usr/include/bits/siginfo.h +/usr/include/bits/signum.h +/usr/include/bits/sigstack.h +/usr/include/bits/sigthread.h +/usr/include/linux/errno.h +/usr/include/sys/ucontext.h +/usr/include/asm/errno.h +/usr/include/asm-generic/errno.h +/usr/include/asm-generic/errno-base.h diff --git a/omega/code_gen/src/output_repr.cc b/omega/code_gen/src/output_repr.cc new file mode 100644 index 0000000..955cc14 --- /dev/null +++ b/omega/code_gen/src/output_repr.cc @@ -0,0 +1,1931 @@ +/***************************************************************************** + Copyright (C) 1994-2000 University of Maryland + Copyright (C) 2008 University of Southern California + Copyright (C) 2009-2010 University of Utah + All Rights Reserved. + + Purpose: + utility functions for outputing CG_outputReprs + + Notes: + + History: + 07/30/10 collect various code outputing into one place, by Chun Chen +*****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include + +namespace omega { + +extern Tuple > projected_nIS; +int var_substitution_threshold = 100; +//protonu. +extern int upperBoundForLevel; +extern int lowerBoundForLevel; +extern bool fillInBounds; +//end--protonu. + +} + + +namespace omega { + +std::pair find_simplest_assignment(const Relation &R_, Variable_ID v, const std::vector &assigned_on_the_fly); + + +namespace { + + + + +void get_stride(const Constraint_Handle &h, Variable_ID &wc, coef_t &step){ + wc = 0; + for(Constr_Vars_Iter i(h,true); i; i++) { + assert(wc == 0); + wc = (*i).var; + step = ((*i).coef); + } +} + +} + +CG_outputRepr* outputIdent(CG_outputBuilder* ocg, const Relation &R_, Variable_ID v, const std::vector &assigned_on_the_fly) { + Relation &R = const_cast(R_); + + switch (v->kind()) { + case Set_Var: { + int pos = v->get_position(); + if (assigned_on_the_fly[pos-1] != NULL) + return assigned_on_the_fly[pos-1]->clone(); + else + return ocg->CreateIdent(v->name()); + break; + } + case Global_Var: { + if (v->get_global_var()->arity() == 0) + return ocg->CreateIdent(v->name()); + else { + /* This should be improved to take into account the possible elimination + of the set variables. */ + int arity = v->get_global_var()->arity(); + //assert(arity <= last_level); + Tuple argList; + // Relation R = Relation::True(arity); + + // name_codegen_vars(R); // easy way to make sure the names are correct. + for(int i = 1; i <= arity; i++) + argList.append(ocg->CreateIdent(R.set_var(i)->name())); + CG_outputRepr *call = ocg->CreateInvoke(v->get_global_var()->base_name(), argList); + return call; + } + break; + } + default: + throw std::invalid_argument("wrong variable type"); + } +} + + +//---------------------------------------------------------------------------- +// Translate equality constraints to if-condition and assignment. +// return.first is right-hand-side of assignment, return.second +// is true if assignment is required. +// -- by chun 07/29/2010 +// ---------------------------------------------------------------------------- +std::pair outputAssignment(CG_outputBuilder *ocg, const Relation &R_, Variable_ID v, Relation &enforced, CG_outputRepr *&if_repr, const std::vector &assigned_on_the_fly) { + Relation &R = const_cast(R_); + + Conjunct *c = R.query_DNF()->single_conjunct(); + + // check whether to generate if-conditions from equality constraints + for (EQ_Iterator ei(c); ei; ei++) + if (!(*ei).has_wildcards() && abs((*ei).get_coef(v)) > 1) { + Relation r(R.n_set()); + F_And *f_super_root = r.add_and(); + F_Exists *fe = f_super_root->add_exists(); + Variable_ID e = fe->declare(); + F_And *f_root = fe->add_and(); + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + if ((*cvi).var == v) + h.update_coef(e, (*cvi).coef); + else + h.update_coef(r.set_var((*cvi).var->get_position()), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, (*cvi).var->function_of()); + h.update_coef(v2, (*cvi).coef); + break; + } + default: + assert(0); + } + h.update_const((*ei).get_const()); + + r.copy_names(R); + r.setup_names(); + + // need if-condition to make sure this loop variable has integer value + if (!Gist(r, copy(enforced), 1).is_obvious_tautology()) { + coef_t coef = (*ei).get_coef(v); + coef_t sign = -((coef>0)?1:-1); + coef = abs(coef); + + CG_outputRepr *term = NULL; + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var != v) { + CG_outputRepr *varRepr = outputIdent(ocg, R, (*cvi).var, assigned_on_the_fly); + coef_t t = sign*(*cvi).coef; + if (t == 1) + term = ocg->CreatePlus(term, varRepr); + else if (t == -1) + term = ocg->CreateMinus(term, varRepr); + else if (t > 0) + term = ocg->CreatePlus(term, ocg->CreateTimes(ocg->CreateInt(t), varRepr)); + else if (t < 0) + term = ocg->CreateMinus(term, ocg->CreateTimes(ocg->CreateInt(-t), varRepr)); + } + coef_t t = sign*(*ei).get_const(); + if (t > 0) + term = ocg->CreatePlus(term, ocg->CreateInt(t)); + else if (t < 0) + term = ocg->CreateMinus(term, ocg->CreateInt(-t)); + + term = ocg->CreateIntegerMod(term, ocg->CreateInt(coef)); + term = ocg->CreateEQ(term, ocg->CreateInt(0)); + + if_repr = ocg->CreateAnd(if_repr, term); + } + + enforced.and_with_EQ(*ei); + enforced.simplify(); + } + + // find the simplest assignment + std::pair a = find_simplest_assignment(R, v, assigned_on_the_fly); + + // now generate assignment + if (a.second < INT_MAX) { + EQ_Handle eq = a.first; + CG_outputRepr *rop_repr = NULL; + + coef_t divider = eq.get_coef(v); + int sign = 1; + if (divider < 0) { + divider = -divider; + sign = -1; + } + + for (Constr_Vars_Iter cvi(eq); cvi; cvi++) + if ((*cvi).var != v) { + CG_outputRepr *var_repr = outputIdent(ocg, R, (*cvi).var, assigned_on_the_fly); + coef_t coef = (*cvi).coef; + if (-sign * coef == -1) + rop_repr = ocg->CreateMinus(rop_repr, var_repr); + else if (-sign * coef < -1) + rop_repr = ocg->CreateMinus(rop_repr, ocg->CreateTimes(ocg->CreateInt(sign * coef), var_repr)); + else if (-sign * coef == 1) + rop_repr = ocg->CreatePlus(rop_repr, var_repr); + else // -sign * coef > 1 + rop_repr = ocg->CreatePlus(rop_repr, ocg->CreateTimes(ocg->CreateInt(-sign * coef), var_repr)); + } + + coef_t c_term = -(eq.get_const() * sign); + + if (c_term > 0) + rop_repr = ocg->CreatePlus(rop_repr, ocg->CreateInt(c_term)); + else if (c_term < 0) + rop_repr = ocg->CreateMinus(rop_repr, ocg->CreateInt(-c_term)); + else if (rop_repr == NULL) + rop_repr = ocg->CreateInt(0); + + if (divider != 1) + rop_repr = ocg->CreateIntegerDivide(rop_repr, ocg->CreateInt(divider)); + + enforced.and_with_EQ(eq); + enforced.simplify(); + + if (a.second > var_substitution_threshold) + return std::make_pair(rop_repr, true); + else + return std::make_pair(rop_repr, false); + } + else + return std::make_pair(static_cast(NULL), false); +} + + +//---------------------------------------------------------------------------- +// Don't use Substitutions class since it can't handle integer +// division. Instead, use relation mapping to a single output +// variable to get substitution. -- by chun, 07/19/2007 +//---------------------------------------------------------------------------- +Tuple outputSubstitution(CG_outputBuilder* ocg, const Relation &R_, const std::vector &assigned_on_the_fly) { + Relation &R = const_cast(R_); + + const int n = R.n_out(); + Tuple oReprList; + + // Find substitution for each output variable + for (int i = 1; i <= n; i++) { + Relation mapping(n, 1); + F_And *f_root = mapping.add_and(); + EQ_Handle h = f_root->add_EQ(); + h.update_coef(mapping.output_var(1), 1); + h.update_coef(mapping.input_var(i), -1); + + Relation S = Composition(mapping, copy(R)); + + std::pair a = find_simplest_assignment(S, S.output_var(1), assigned_on_the_fly); + + if (a.second < INT_MAX) { + while (a.second > 0) { + EQ_Handle eq = a.first; + std::set candidates; + for (Constr_Vars_Iter cvi(eq); cvi; cvi++) + if ((*cvi).var->kind() == Input_Var) + candidates.insert((*cvi).var->get_position()); + + bool changed = false; + for (std::set::iterator j = candidates.begin(); j != candidates.end(); j++) { + Relation S2 = Project(copy(S), *j, Input_Var); + std::pair a2 = find_simplest_assignment(S2, S2.output_var(1), assigned_on_the_fly); + if (a2.second <= a.second) { + S = S2; + a = a2; + changed = true; + break; + } + } + if (!changed) + break; + } + } + + if (a.second < INT_MAX) { + CG_outputRepr *repr = NULL; + EQ_Handle eq = a.first; + Variable_ID v = S.output_var(1); + + for (int j = 1; j <= S.n_inp(); j++) + S.name_input_var(j, R.input_var(j)->name()); + S.setup_names(); + + int d = eq.get_coef(v); + assert(d != 0); + int sign = (d>0)?-1:1; + d = -sign * d; + for (Constr_Vars_Iter cvi(eq); cvi; cvi++) + if ((*cvi).var != v) { + int coef = sign * (*cvi).coef; + CG_outputRepr *op = outputIdent(ocg, S, (*cvi).var, assigned_on_the_fly); + if (coef > 1) + op = ocg->CreateTimes(ocg->CreateInt(coef), op); + else if (coef < -1) + op = ocg->CreateTimes(ocg->CreateInt(-coef), op); + if (coef > 0) + repr = ocg->CreatePlus(repr, op); + else if (coef < 0) + repr = ocg->CreateMinus(repr, op); + } + + int c = sign * eq.get_const(); + if (c > 0) + repr = ocg->CreatePlus(repr, ocg->CreateInt(c)); + else if (c < 0) + repr = ocg->CreateMinus(repr, ocg->CreateInt(-c)); + else if (repr == NULL) + repr = ocg->CreateInt(0); + + if (d != 1) + repr = ocg->CreateIntegerDivide(repr, ocg->CreateInt(d)); + + oReprList.append(repr); + } + else + oReprList.append(NULL); + } + + return oReprList; +} + +namespace { + +Relation create_stride_on_bound(int n, const std::map &lb, coef_t stride) { + Relation result(n); + F_And *f_root = result.add_and(); + EQ_Handle h = f_root->add_stride(stride); + + for (std::map::const_iterator i = lb.begin(); i != lb.end(); i++) { + if (i->first == NULL) + h.update_const(i->second); + else { + switch(i->first->kind()) { + case Input_Var: { + int pos = i->first->get_position(); + h.update_coef(result.set_var(pos), i->second); + break; + } + case Global_Var: { + Global_Var_ID g = i->first->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = result.get_local(g); + else + v = result.get_local(g, i->first->function_of()); + h.update_coef(v, i->second); + break; + } + default: + assert(0); + } + } + } + + return result; +} + +} + +//---------------------------------------------------------------------------- +// Find the most restrictive common stride constraint for a set of +// relations. -- by chun, 05/20/09 +// ---------------------------------------------------------------------------- +Relation greatest_common_step(const Tuple &I, const Tuple &active, int level, const Relation &known) { + assert(I.size() == active.size()); + int n = 0; + + std::vector I1, I2; + for (int i = 1; i <= I.size(); i++) + if (active[i]) { + if (n == 0) + n = I[i].n_set(); + + Relation r1; + if (known.is_null()) + r1 = copy(I[i]); + else { + r1 = Intersection(copy(I[i]), copy(known)); + r1.simplify(); + } + I1.push_back(r1); + Relation r2 = Gist(copy(I[i]), copy(known)); + assert(r2.is_upper_bound_satisfiable()); + if (r2.is_obvious_tautology()) + return Relation::True(n); + I2.push_back(r2); + } + + std::vector is_exact(I2.size(), true); + std::vector step(I2.size(), 0); + std::vector messy_step(I2.size(), 0); + Variable_ID t_col = set_var(level); + std::map lb; + + // first check all clean strides: t_col = ... (mod step) + for (size_t i = 0; i < I2.size(); i++) { + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + + bool is_degenerated = false; + for (EQ_Iterator e = c->EQs(); e; e++) { + coef_t coef = abs((*e).get_coef(t_col)); + if (coef != 0 && !(*e).has_wildcards()) { + is_degenerated = true; + break; + } + } + if (is_degenerated) + continue; + + for (EQ_Iterator e = c->EQs(); e; e++) { + if ((*e).has_wildcards()) { + coef_t coef = abs((*e).get_coef(t_col)); + if (coef == 0) + continue; + if (coef != 1) { + is_exact[i] = false; + continue; + } + + coef_t this_step = abs(Constr_Vars_Iter(*e, true).curr_coef()); + assert(this_step != 1); + + if (lb.size() != 0) { + Relation test = create_stride_on_bound(n, lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + } + else + is_exact[i] = false; + } + else { + // try to find a lower bound that hits on stride + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + for (GEQ_Iterator ge = c->GEQs(); ge; ge++) { + if ((*ge).has_wildcards() || (*ge).get_coef(t_col) != 1) + continue; + + std::map cur_lb; + for (Constr_Vars_Iter cv(*ge); cv; cv++) + cur_lb[cv.curr_var()] = cv.curr_coef(); + cur_lb[NULL] = (*ge).get_const(); + + Relation test = create_stride_on_bound(n, cur_lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + + lb = cur_lb; + break; + } + } + + // no clean lower bound, thus we use this modular constraint as is + if (lb.size() == 0) { + std::map cur_lb; + int wild_count = 0; + for (Constr_Vars_Iter cv(*e); cv; cv++) + if (cv.curr_var()->kind() == Wildcard_Var) + wild_count++; + else + cur_lb[cv.curr_var()] = cv.curr_coef(); + cur_lb[NULL] = (*e).get_const(); + + if (wild_count == 1) { + lb = cur_lb; + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + } + } + + if (lb.size() == 0) + is_exact[i] = false; + } + } + } + } + + // aggregate all exact steps + coef_t global_step = 0; + for (size_t i = 0; i < is_exact.size(); i++) + if (is_exact[i]) + global_step = gcd(global_step, step[i]); + if (global_step == 1) + return Relation::True(n); + + // now check all messy strides: a*t_col = ... (mod step) + for (size_t i = 0; i < I2.size(); i++) + if (!is_exact[i]) { + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + for (EQ_Iterator e = c->EQs(); e; e++) { + coef_t coef = abs((*e).get_coef(t_col)); + if (coef == 0 || coef == 1) + continue; + + // make a guess for messy stride condition -- by chun 07/27/2007 + coef_t this_step = abs(Constr_Vars_Iter(*e, true).curr_coef()); + this_step /= gcd(this_step, coef); + this_step = gcd(global_step, this_step); + if (this_step == 1) + continue; + + if (lb.size() != 0) { + Relation test = create_stride_on_bound(n, lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + } + } + else { + // try to find a lower bound that hits on stride + Conjunct *c = I2[i].query_DNF()->single_conjunct(); + for (GEQ_Iterator ge = c->GEQs(); ge; ge++) { + if ((*ge).has_wildcards() || (*ge).get_coef(t_col) != 1) + continue; + + std::map cur_lb; + + for (Constr_Vars_Iter cv(*ge); cv; cv++) + cur_lb[cv.curr_var()] = cv.curr_coef(); + + cur_lb[NULL] = (*ge).get_const(); + + Relation test = create_stride_on_bound(n, cur_lb, this_step); + if (Gist(test, copy(I1[i])).is_obvious_tautology()) { + if (step[i] == 0) + step[i] = this_step; + else + step[i] = lcm(step[i], this_step); + + lb = cur_lb; + break; + } + } + } + } + } + + // aggregate all non-exact steps + for (size_t i = 0; i < is_exact.size(); i++) + if (!is_exact[i]) + global_step = gcd(global_step, step[i]); + if (global_step == 1 || global_step == 0) + return Relation::True(n); + + Relation result = create_stride_on_bound(n, lb, global_step); + + // check for statements that haven't been factored into global step + for (size_t i = 0; i < I1.size(); i++) + if (step[i] == 0) { + if (!Gist(copy(result), copy(I1[i])).is_obvious_tautology()) + return Relation::True(n); + } + + return result; +} + + +//----------------------------------------------------------------------------- +// Substitute variables in a statement according to mapping function. +//----------------------------------------------------------------------------- +CG_outputRepr* outputStatement(CG_outputBuilder *ocg, CG_outputRepr *stmt, int indent, const Relation &mapping_, const Relation &known_, const std::vector &assigned_on_the_fly) { + Relation mapping = copy(mapping_); + Relation known = copy(known_); + Tuple loop_vars; + + for (int i = 1; i <= mapping.n_inp(); i++) + loop_vars.append(mapping.input_var(i)->name()); + + // discard non-existant variables from iteration spaces -- by chun 12/31/2008 + if (known.n_set() > mapping.n_out()) { + Relation r(known.n_set(), mapping.n_out()); + F_And *f_root = r.add_and(); + for (int i = 1; i <= mapping.n_out(); i++) { + EQ_Handle h = f_root->add_EQ(); + h.update_coef(r.input_var(i), 1); + h.update_coef(r.output_var(i), -1); + } + known = Range(Restrict_Domain(r, known)); + known.simplify(); + } + + // remove modular constraints from known to simplify mapping process -- by chun 11/10/2008 + Relation k(known.n_set()); + F_And *f_root = k.add_and(); + Conjunct *c = known.query_DNF()->single_conjunct(); + for (EQ_Iterator e = c->EQs(); e; e++) { + if (!(*e).has_wildcards()) + f_root->add_EQ(*e); + } + k.simplify(); + + // get variable substituion list + Relation Inv_mapping = Restrict_Domain(Inverse(mapping), k); + Tuple sList = outputSubstitution(ocg, Inv_mapping, assigned_on_the_fly); + + return ocg->CreatePlaceHolder(indent, stmt, sList, loop_vars); +} + + +// find floor definition for variable such as m-3 <= 4v <= m +bool findFloorInequality(Relation &r, Variable_ID v, GEQ_Handle &h, Variable_ID excluded) { + Conjunct *c = r.single_conjunct(); + + std::set var_checked; + std::stack var_checking; + var_checking.push(v); + + while (!var_checking.empty()) { + Variable_ID v2 = var_checking.top(); + var_checking.pop(); + + bool is_floor = false; + for (GEQ_Iterator gi(c); gi; gi++) { + if (excluded != NULL && (*gi).get_coef(excluded) != 0) + continue; + + coef_t a = (*gi).get_coef(v2); + if (a < 0) { + for (GEQ_Iterator gi2(c); gi2; gi2++) { + coef_t b = (*gi2).get_coef(v2); + if (b == -a && (*gi).get_const()+(*gi2).get_const() < -a) { + bool match = true; + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + if ((*gi2).get_coef((*cvi).var) != -(*cvi).coef) { + match = false; + break; + } + if (!match) + continue; + for (Constr_Vars_Iter cvi(*gi2); cvi; cvi++) + if ((*gi).get_coef((*cvi).var) != -(*cvi).coef) { + match = false; + break; + } + if (match) { + var_checked.insert(v2); + is_floor = true; + if (v == v2) + h = *gi; + + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + if (((*cvi).var->kind() == Exists_Var || (*cvi).var->kind() == Wildcard_Var) && + var_checked.find((*cvi).var) == var_checked.end()) + var_checking.push((*cvi).var); + + break; + } + } + } + if (is_floor) + break; + } + } + if (!is_floor) + return false; + } + return true; +} + + + + +//----------------------------------------------------------------------------- +// Output a reqular equality or inequality to conditions. +// e.g. (i=5*j) +//----------------------------------------------------------------------------- +CG_outputRepr* output_as_guard(CG_outputBuilder* ocg, const Relation &guards_in, Constraint_Handle e, bool is_equality, const std::vector &assigned_on_the_fly) { + Relation &guards = const_cast(guards_in); + if (e.has_wildcards()) + throw std::invalid_argument("constraint must not have wildcard"); + + Variable_ID v = (*Constr_Vars_Iter(e)).var; + + coef_t saved_coef = ((e).get_coef(v)); + int sign = saved_coef < 0 ? -1 : 1; + + (e).update_coef_during_simplify(v, -saved_coef+sign); + CG_outputRepr* rop = outputEasyBoundAsRepr(ocg, guards, e, v, false, 0, assigned_on_the_fly); + (e).update_coef_during_simplify(v,saved_coef-sign); + + CG_outputRepr* lop = outputIdent(ocg, guards, v, assigned_on_the_fly); + if (abs(saved_coef) != 1) + lop = ocg->CreateTimes(ocg->CreateInt(abs(saved_coef)), lop); + + + if (is_equality) { + return ocg->CreateEQ(lop, rop); + } + else { + if (saved_coef < 0) + return ocg->CreateLE(lop, rop); + else + return ocg->CreateGE(lop, rop); + } +} + + +//----------------------------------------------------------------------------- +// Output stride conditions from equalities. +// e.g. (exists alpha: i = 5*alpha) +//----------------------------------------------------------------------------- +CG_outputRepr *output_EQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly) { + Relation guards = const_cast(guards_in); + Conjunct *c = guards.single_conjunct(); + + CG_outputRepr *eqRepr = NULL; + + for (EQ_Iterator ei(c->EQs()); ei; ei++) { + Variable_ID wc = NULL; + for (Constr_Vars_Iter cvi((*ei), true); cvi; cvi++) { + if (wc != NULL) + throw codegen_error("Can't generate equality condition with multiple wildcards"); + else + wc = (*cvi).var; + } + if (wc == NULL) + continue; + + coef_t step = (*ei).get_coef(wc); + + (*ei).update_coef_during_simplify(wc, 1-step); + CG_outputRepr* lop = outputEasyBoundAsRepr(ocg, guards, (*ei), wc, false, 0, assigned_on_the_fly); + (*ei).update_coef_during_simplify(wc, step-1); + + CG_outputRepr* rop = ocg->CreateInt(abs(step)); + CG_outputRepr* intMod = ocg->CreateIntegerMod(lop, rop); + CG_outputRepr* eqNode = ocg->CreateEQ(intMod, ocg->CreateInt(0)); + + eqRepr = ocg->CreateAnd(eqRepr, eqNode); + } + + return eqRepr; +} + + + +//----------------------------------------------------------------------------- +// Output hole conditions created by inequalities involving wildcards. +// e.g. (exists alpha: 4*alpha <= i <= 5*alpha) +// Collect wildcards +// For each whildcard +// collect lower and upper bounds in which wildcard appears +// For each lower bound +// create constraint with each upper bound +//----------------------------------------------------------------------------- +CG_outputRepr *output_GEQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly) { + Relation guards = const_cast(guards_in); + Conjunct *c = guards.single_conjunct(); + + CG_outputRepr* geqRepr = NULL; + + std::set non_orphan_wildcard; + for (GEQ_Iterator gi(c); gi; gi++) { + int num_wild = 0; + Variable_ID first_one; + for (Constr_Vars_Iter cvi(*gi, true); cvi; cvi++) { + num_wild++; + if (num_wild == 1) + first_one = (*cvi).var; + else + non_orphan_wildcard.insert((*cvi).var); + } + if (num_wild > 1) + non_orphan_wildcard.insert(first_one); + } + + for (int i = 1; i <= (*(c->variables())).size(); i++) { + Variable_ID wc = (*(c->variables()))[i]; + if (wc->kind() == Wildcard_Var && non_orphan_wildcard.find(wc) == non_orphan_wildcard.end()) { + Tuple lower, upper; + for (GEQ_Iterator gi(c); gi; gi++) { + if((*gi).get_coef(wc) > 0) + lower.append(*gi); + else if((*gi).get_coef(wc) < 0) + upper.append(*gi); + } + + // low: c*alpha - x >= 0 + // up: -d*alpha + y >= 0 + for (Tuple_Iterator low(lower); low; low++) { + for (Tuple_Iterator up(upper); up; up++) { + coef_t low_coef = (*low).get_coef(wc); + coef_t up_coef = (*up).get_coef(wc); + + (*low).update_coef_during_simplify(wc, 1-low_coef); + CG_outputRepr* lowExpr = outputEasyBoundAsRepr(ocg, guards, *low, wc, false, 0, assigned_on_the_fly); + (*low).update_coef_during_simplify(wc, low_coef-1); + + (*up).update_coef_during_simplify(wc, -1-up_coef); + CG_outputRepr* upExpr = outputEasyBoundAsRepr(ocg, guards, *up, wc, false, 0, assigned_on_the_fly); + (*up).update_coef_during_simplify(wc, up_coef+1); + + CG_outputRepr* intDiv = ocg->CreateIntegerDivide(upExpr, ocg->CreateInt(-up_coef)); + CG_outputRepr* rop = ocg->CreateTimes(ocg->CreateInt(low_coef), intDiv); + CG_outputRepr* geqNode = ocg->CreateLE(lowExpr, rop); + + geqRepr = ocg->CreateAnd(geqRepr, geqNode); + } + } + } + } + + if (non_orphan_wildcard.size() > 0) { + // e.g. c*alpha - x >= 0 (*) + // -d*alpha + y >= 0 (*) + // e1*alpha + f1*beta + g1 >= 0 (**) + // e2*alpha + f2*beta + g2 >= 0 (**) + // ... + // TODO: should generate a testing loop for alpha using its lower and + // upper bounds from (*) constraints and do the same if-condition test + // for beta from each pair of opposite (**) constraints as above, + // and exit the loop when if-condition satisfied. + throw codegen_error("Can't generate multiple wildcard GEQ guards right now"); + } + + return geqRepr; +} + + +//----------------------------------------------------------------------------- +// Translate all constraints in a relation to guard conditions. +//----------------------------------------------------------------------------- +CG_outputRepr *outputGuard(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly) { + Relation &guards = const_cast(guards_in); + if (guards.is_null() || guards.is_obvious_tautology()) + return NULL; + + CG_outputRepr* nodeRepr = NULL; + + CG_outputRepr *eqStrideRepr = output_EQ_strides(ocg, guards, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, eqStrideRepr); + + CG_outputRepr *geqStrideRepr = output_GEQ_strides(ocg, guards, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, geqStrideRepr); + + Conjunct *c = guards.single_conjunct(); + for(EQ_Iterator ei(c->EQs()); ei; ei++) + if (!(*ei).has_wildcards()) { + CG_outputRepr *eqRepr = output_as_guard(ocg, guards, (*ei), true, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, eqRepr); + } + for(GEQ_Iterator gi(c->GEQs()); gi; gi++) + if (!(*gi).has_wildcards()) { + CG_outputRepr *geqRepr = output_as_guard(ocg, guards, (*gi), false, assigned_on_the_fly); + nodeRepr = ocg->CreateAnd(nodeRepr, geqRepr); + } + + return nodeRepr; +} + + +//----------------------------------------------------------------------------- +// one is 1 for LB +// this function is overloaded should replace the original one +//----------------------------------------------------------------------------- +CG_outputRepr *outputLBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, + Relation &bounds, Variable_ID v, + coef_t stride, const EQ_Handle &strideEQ, + Relation known, const std::vector &assigned_on_the_fly) { +#if ! defined NDEBUG + coef_t v_coef; + assert((v_coef = g.get_coef(v)) > 0); +#endif + + std::string s; + CG_outputRepr *lbRepr; + if (stride == 1) { + lbRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 1, assigned_on_the_fly); + } + else { + if (!boundHitsStride(g,v,strideEQ,stride,known)) { + bounds.setup_names(); // boundsHitsStride resets variable names + + CG_stringBuilder oscg; + std::string c = GetString(outputEasyBoundAsRepr(&oscg, bounds, strideEQ, v, true, 0, assigned_on_the_fly)); + CG_outputRepr *cRepr = NULL; + if (c != std::string("0")) + cRepr = outputEasyBoundAsRepr(ocg, bounds, strideEQ, v, true, 0, assigned_on_the_fly); + std::string LoverM = GetString(outputEasyBoundAsRepr(&oscg, bounds, g, v, false, 1, assigned_on_the_fly)); + CG_outputRepr *LoverMRepr = NULL; + if (LoverM != std::string("0")) + LoverMRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 1, assigned_on_the_fly); + + if (code_gen_debug > 2) { + fprintf(DebugFile,"::: LoverM is %s\n", LoverM.c_str()); + fprintf(DebugFile,"::: c is %s\n", c.c_str()); + } + + int complexity1 = 0, complexity2 = 0; + for (size_t i = 0; i < c.length(); i++) + if (c[i] == '+' || c[i] == '-' || c[i] == '*' || c[i] == '/') + complexity1++; + else if (c[i] == ',') + complexity1 += 2; + for (size_t i = 0; i < LoverM.length(); i++) + if (LoverM[i] == '+' || LoverM[i] == '-' || LoverM[i] == '*' || LoverM[i] == '/') + complexity2++; + else if (LoverM[i] == ',') + complexity2 += 2; + + if (complexity1 < complexity2) { + CG_outputRepr *idUp = LoverMRepr; + CG_outputRepr *c1Repr = ocg->CreateCopy(cRepr); + idUp = ocg->CreateMinus(idUp, c1Repr); + idUp = ocg->CreatePlus(idUp, ocg->CreateInt(stride-1)); + CG_outputRepr *idLow = ocg->CreateInt(stride); + lbRepr = ocg->CreateTimes(ocg->CreateInt(stride), + ocg->CreateIntegerDivide(idUp, idLow)); + lbRepr = ocg->CreatePlus(lbRepr, cRepr); + } + else { + CG_outputRepr *LoverM1Repr = ocg->CreateCopy(LoverMRepr); + CG_outputRepr *imUp = ocg->CreateMinus(cRepr, LoverM1Repr); + CG_outputRepr *imLow = ocg->CreateInt(stride); + CG_outputRepr *intMod = ocg->CreateIntegerMod(imUp, imLow); + lbRepr = ocg->CreatePlus(LoverMRepr, intMod); + } + } + else { + // boundsHitsStride resets variable names + bounds.setup_names(); + lbRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 0, assigned_on_the_fly); + } + } + + return lbRepr; +} + +//----------------------------------------------------------------------------- +// one is -1 for UB +// this function is overloaded should replace the original one +//----------------------------------------------------------------------------- +CG_outputRepr *outputUBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, + Relation & bounds, + Variable_ID v, + coef_t /*stride*/, // currently unused + const EQ_Handle &/*strideEQ*/, //currently unused + const std::vector &assigned_on_the_fly) { + assert(g.get_coef(v) < 0); + CG_outputRepr* upRepr = outputEasyBoundAsRepr(ocg, bounds, g, v, false, 0, assigned_on_the_fly); + return upRepr; +} + +//----------------------------------------------------------------------------- +// Print the expression for the variable given as v. Works for both +// GEQ's and EQ's, but produces intDiv (not intMod) when v has a nonunit +// coefficient. So it is OK for loop bounds, but for checking stride +// constraints, you want to make sure the coef of v is 1, and insert the +// intMod yourself. +// +// original name is outputEasyBound +//----------------------------------------------------------------------------- +CG_outputRepr* outputEasyBoundAsRepr(CG_outputBuilder* ocg, Relation &bounds, + const Constraint_Handle &g, Variable_ID v, + bool ignoreWC, + int ceiling, + const std::vector &assigned_on_the_fly) { + // assert ignoreWC => g is EQ + // rewrite constraint as foo (== or <= or >=) v, return foo as string + + CG_outputRepr* easyBoundRepr = NULL; + + coef_t v_coef = g.get_coef(v); + int v_sign = v_coef > 0 ? 1 : -1; + v_coef *= v_sign; + assert(v_coef > 0); + // foo is (-constraint)/v_sign/v_coef + + int sign_adj = -v_sign; + + //---------------------------------------------------------------------- + // the following generates +- cf*varName + //---------------------------------------------------------------------- + for(Constr_Vars_Iter c2(g, false); c2; c2++) { + if ((*c2).var != v && (!ignoreWC || (*c2).var->kind()!=Wildcard_Var)) { + + coef_t cf = (*c2).coef*sign_adj; + assert(cf != 0); + + CG_outputRepr *varName; + if ((*c2).var->kind() == Wildcard_Var) { + GEQ_Handle h; + if (!findFloorInequality(bounds, (*c2).var, h, v)) { + if (easyBoundRepr != NULL) { + easyBoundRepr->clear(); + delete easyBoundRepr; + } + return NULL; + } + varName = outputEasyBoundAsRepr(ocg, bounds, h, (*c2).var, false, 0, assigned_on_the_fly); + } + else { + varName = outputIdent(ocg, bounds, (*c2).var, assigned_on_the_fly); + } + CG_outputRepr *cfRepr = NULL; + + if (cf > 1) { + cfRepr = ocg->CreateInt(cf); + CG_outputRepr* rbRepr = ocg->CreateTimes(cfRepr, varName); + easyBoundRepr = ocg->CreatePlus(easyBoundRepr, rbRepr); + } + else if (cf < -1) { + cfRepr = ocg->CreateInt(-cf); + CG_outputRepr* rbRepr = ocg->CreateTimes(cfRepr, varName); + easyBoundRepr = ocg->CreateMinus(easyBoundRepr, rbRepr); + } + else if (cf == 1) { + easyBoundRepr = ocg->CreatePlus(easyBoundRepr, varName); + } + else if (cf == -1) { + easyBoundRepr = ocg->CreateMinus(easyBoundRepr, varName); + } + } + } + + if (g.get_const()) { + coef_t cf = g.get_const()*sign_adj; + assert(cf != 0); + if (cf > 0) { + easyBoundRepr = ocg->CreatePlus(easyBoundRepr, ocg->CreateInt(cf)); + } + else { + easyBoundRepr = ocg->CreateMinus(easyBoundRepr, ocg->CreateInt(-cf)); + } + } + else { + if(easyBoundRepr == NULL) { + easyBoundRepr = ocg->CreateInt(0); + } + } + + if (v_coef > 1) { + assert(ceiling >= 0); + if (ceiling) { + easyBoundRepr= ocg->CreatePlus(easyBoundRepr, ocg->CreateInt(v_coef-1)); + } + easyBoundRepr = ocg->CreateIntegerDivide(easyBoundRepr, ocg->CreateInt(v_coef)); + } + + return easyBoundRepr; +} + + +//---------------------------------------------------------------------------- +// Translate inequality constraints to loop or assignment. +// if return.second is true, return.first is loop structure, +// otherwise it is assignment. +// ---------------------------------------------------------------------------- +std::pair outputBounds(CG_outputBuilder* ocg, const Relation &bounds, Variable_ID v, int indent, Relation &enforced, const std::vector &assigned_on_the_fly) { + Relation b = copy(bounds); + Conjunct *c = b.query_DNF()->single_conjunct(); + + // Elaborate stride simplification which is complementary to gist function + // since we further target the specific loop variable. -- by chun 08/07/2008 + Relation r1 = Relation::True(b.n_set()), r2 = Relation::True(b.n_set()); + for (EQ_Iterator ei(c); ei; ei++) { + if ((*ei).get_coef(v) != 0 && (*ei).has_wildcards()) { // stride condition found + coef_t sign; + if ((*ei).get_coef(v) > 0) + sign = 1; + else + sign = -1; + + coef_t stride = 0; + for (Constr_Vars_Iter cvi(*ei, true); cvi; cvi++) + if ((*cvi).var->kind() == Wildcard_Var) { + stride = abs((*cvi).coef); + break; + } + + // check if stride hits lower bound + bool found_match = false; + if (abs((*ei).get_coef(v)) != 1) { // expensive matching for non-clean stride condition + coef_t d = stride / gcd(abs((*ei).get_coef(v)), stride); + Relation r3 = Relation::True(b.n_set()); + r3.and_with_EQ(*ei); + + for (GEQ_Iterator gi(c); gi; gi++) { + if ((*gi).get_coef(v) == 1 && !(*gi).has_wildcards()) { + Relation r4(b.n_set()); + F_And *f_root = r4.add_and(); + Stride_Handle h = f_root->add_stride(d); + + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h.update_coef(r4.set_var(pos), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r4.get_local(g); + else + v = r4.get_local(g, (*cvi).var->function_of()); + h.update_coef(v, (*cvi).coef); + break; + } + default: + fprintf(DebugFile, "can't deal with the variable type in lower bound\n"); + return std::make_pair(static_cast(NULL), false); + } + h.update_const((*gi).get_const()); + + Relation r5 = Gist(copy(r3), Intersection(copy(r4), copy(enforced))); + + // replace original stride condition with striding from this lower bound + if (r5.is_obvious_tautology()) { + r1 = Intersection(r1, r4); + found_match = true; + break; + } + } + } + } + else { + for (GEQ_Iterator gi(c); gi; gi++) { + if ((*gi).get_coef(v) == abs((*ei).get_coef(v)) && !(*gi).has_wildcards()) { // potential matching lower bound found + Relation r(b.n_set()); + Stride_Handle h = r.add_and()->add_stride(stride); + + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + if ((*cvi).var != v) { + int t1 = int_mod((*cvi).coef, stride); + if (t1 != 0) { + coef_t t2 = enforced.query_variable_mod(enforced.set_var(pos), stride); + if (t2 != posInfinity) + h.update_const(t1*t2); + else + h.update_coef(r.set_var(pos), t1); + } + } + else + h.update_coef(r.set_var(pos), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = enforced.get_local(g); + else + v = enforced.get_local(g, (*cvi).var->function_of()); + coef_t t = enforced.query_variable_mod(v, stride); + if (t != posInfinity) + h.update_const(t*(*cvi).coef); + else { + Variable_ID v2; + if (g->arity() == 0) + v2 = r.get_local(g); + else + v2 = r.get_local(g, (*cvi).var->function_of()); + h.update_coef(v2, (*cvi).coef); + } + break; + } + default: + fprintf(DebugFile, "can't deal with the variable type in lower bound\n"); + return std::make_pair(static_cast(NULL), false); + } + h.update_const((*gi).get_const()); + + bool t = true; + { + Conjunct *c2 = r.query_DNF()->single_conjunct(); + EQ_Handle h2; + for (EQ_Iterator ei2(c2); ei2; ei2++) { + h2 = *ei2; + break; + } + + int sign; + if (h2.get_coef(v) == (*ei).get_coef(v)) + sign = 1; + else + sign = -1; + + t = int_mod(h2.get_const() - sign * (*ei).get_const(), stride) == 0; + + if (t != false) + for (Constr_Vars_Iter cvi(h2); cvi; cvi++) + if ((*cvi).var->kind() != Wildcard_Var && + int_mod((*cvi).coef - sign * (*ei).get_coef((*cvi).var), stride) != 0) { + t = false; + break; + } + + if (t != false) + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var->kind() != Wildcard_Var && + int_mod((*cvi).coef - sign * h2.get_coef((*cvi).var), stride) != 0) { + t = false; + break; + } + + } + + if (t) { + // replace original stride condition with striding from this lower bound + F_And *f_root = r1.and_with_and(); + Stride_Handle h = f_root->add_stride(stride); + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + h.update_coef(r1.set_var((*cvi).var->get_position()), (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID v; + if (g->arity() == 0) + v = r1.get_local(g); + else + v = r1.get_local(g, (*cvi).var->function_of()); + h.update_coef(v, (*cvi).coef); + break; + } + default: + fprintf(DebugFile, "can't deal with the variable type in lower bound\n"); + return std::make_pair(static_cast(NULL), false); + } + h.update_const((*gi).get_const()); + + found_match = true; + break; + } + } + } + } + + if (!found_match) + r1.and_with_EQ(*ei); + } + else if ((*ei).get_coef(v) == 0) { + Relation r3 = Relation::True(b.n_set()); + r3.and_with_EQ(*ei); + Relation r4 = Gist(r3, copy(enforced)); + if (!r4.is_obvious_tautology()) + r2.and_with_EQ(*ei); + } + else + r2.and_with_EQ(*ei); + } + + // restore remaining inequalities + { + std::map exists_mapping; + F_Exists *fe = r2.and_with_and()->add_exists(); + F_And *f_root = fe->add_and(); + for (GEQ_Iterator gi(c); gi; gi++) { + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) { + Variable_ID v = cvi.curr_var(); + switch (v->kind()) { + case Input_Var: { + int pos = v->get_position(); + h.update_coef(r2.set_var(pos), cvi.curr_coef()); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find(v); + Variable_ID e; + if (p == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[v] = e; + } + else + e = (*p).second; + h.update_coef(e, cvi.curr_coef()); + break; + } + case Global_Var: { + Global_Var_ID g = v->get_global_var(); + Variable_ID v2; + if (g->arity() == 0) + v2 = r2.get_local(g); + else + v2 = r2.get_local(g, v->function_of()); + h.update_coef(v2, cvi.curr_coef()); + break; + } + default: + assert(0); + } + } + h.update_const((*gi).get_const()); + } + } + + // overwrite original bounds + { + r1.simplify(); + r2.simplify(); + Relation b2 = Intersection(r1, r2); + b2.simplify(); + for (int i = 1; i <= b.n_set(); i++) + b2.name_set_var(i, b.set_var(i)->name()); + b2.setup_names(); + b = b2; + c = b.query_DNF()->single_conjunct(); + } + + + // get loop strides + EQ_Handle strideEQ; + bool foundStride = false; // stride that can be translated to loop + bool foundSimpleStride = false; // stride that starts from const value + coef_t step = 1; + int num_stride = 0; + + for (EQ_Iterator ei(c); ei; ei++) { + if ((*ei).get_coef(v) != 0 && (*ei).has_wildcards()) { + num_stride++; + + if (abs((*ei).get_coef(v)) != 1) + continue; + + bool t = true; + coef_t d = 1; + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var->kind() == Wildcard_Var) { + assert(d==1); + d = abs((*cvi).coef); + } + else if ((*cvi).var->kind() == Input_Var) { + if ((*cvi).var != v) + t = false; + } + else + t = false; + + if (d > step) { + step = d; + foundSimpleStride = t; + strideEQ = *ei; + foundStride = true; + } + } + } + + // More than one stride or complex stride found, we should move all + // but strideEQ to body's guard condition. alas, not implemented. + if (!(num_stride == 0 || (num_stride == 1 && foundStride))) + return std::make_pair(static_cast(NULL), false); + + // get loop bounds + int lower_bounds = 0, upper_bounds = 0; + Tuple lbList; + Tuple ubList; + coef_t const_lb = negInfinity, const_ub = posInfinity; + for (GEQ_Iterator g(c); g; g++) { + coef_t coef = (*g).get_coef(v); + if (coef == 0) + continue; + else if (coef > 0) { // lower bound + lower_bounds++; + if ((*g).is_const(v) && !foundStride) { + //no variables but v in constr + coef_t L,m; + L = -((*g).get_const()); + + m = (*g).get_coef(v); + coef_t sb = (int) (ceil(((float) L) /m)); + set_max(const_lb, sb); + } + else if ((*g).is_const(v) && foundSimpleStride) { + // no variables but v in constr + //make LB fit the stride constraint + coef_t L,m,s,c; + L = -((*g).get_const()); + m = (*g).get_coef(v); + s = step; + c = strideEQ.get_const(); + coef_t sb = (s * (int) (ceil( (float) (L - (c * m)) /(s*m))))+ c; + set_max(const_lb, sb); + } + else + lbList.append(outputLBasRepr(ocg, *g, b, v, step, strideEQ, enforced, assigned_on_the_fly)); + } + else { // upper bound + upper_bounds++; + if ((*g).is_const(v)) { + // no variables but v in constraint + set_min(const_ub,-(*g).get_const()/(*g).get_coef(v)); + } + else + ubList.append(outputUBasRepr(ocg, *g, b, v, step, strideEQ, assigned_on_the_fly)); + } + } + + CG_outputRepr *lbRepr = NULL; + CG_outputRepr *ubRepr = NULL; + if (const_lb != negInfinity) + lbList.append(ocg->CreateInt(const_lb)); + if (lbList.size() > 1) + lbRepr = ocg->CreateInvoke("max", lbList); + else if (lbList.size() == 1) + lbRepr = lbList[1]; + + //protonu + if(fillInBounds && lbList.size() == 1 && const_lb != negInfinity) + lowerBoundForLevel = const_lb; + //end-protonu + + if (const_ub != posInfinity) + ubList.append(ocg->CreateInt(const_ub)); + if (ubList.size() > 1) + ubRepr = ocg->CreateInvoke("min", ubList); + else if (ubList.size() == 1) + ubRepr = ubList[1]; + + //protonu + if(fillInBounds && const_ub != posInfinity) + upperBoundForLevel = const_ub; + //end-protonu + + if (upper_bounds == 0 || lower_bounds == 0) { + return std::make_pair(static_cast(NULL), false); + } + else { + // bookkeeping catched constraints in new_knwon + F_Exists *fe = enforced.and_with_and()->add_exists(); + F_And *f_root = fe->add_and(); + std::map exists_mapping; + std::stack > floor_geq_stack; + std::set floor_var_set; + + if (foundStride) { + EQ_Handle h = f_root->add_EQ(); + for (Constr_Vars_Iter cvi(strideEQ); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h.update_coef(enforced.set_var(pos), (*cvi).coef); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find((*cvi).var); + Variable_ID e; + if (p == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[(*cvi).var] = e; + } + else + e = (*p).second; + h.update_coef(e, (*cvi).coef); + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID e; + if (g->arity() == 0) + e = enforced.get_local(g); + else + e = enforced.get_local(g, (*cvi).var->function_of()); + h.update_coef(e, (*cvi).coef); + break; + } + default: + assert(0); + } + h.update_const(strideEQ.get_const()); + } + + for (GEQ_Iterator gi(c); gi; gi++) + if ((*gi).get_coef(v) != 0) { + GEQ_Handle h = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(*gi); cvi; cvi++) + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h.update_coef(enforced.set_var(pos), (*cvi).coef); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map::iterator p = exists_mapping.find((*cvi).var); + Variable_ID e; + if (p == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[(*cvi).var] = e; + } + else + e = (*p).second; + h.update_coef(e, (*cvi).coef); + + if (floor_var_set.find((*cvi).var) == floor_var_set.end()) { + GEQ_Handle h2; + findFloorInequality(b, (*cvi).var, h2, v); + floor_geq_stack.push(std::make_pair(h2, (*cvi).var)); + floor_var_set.insert((*cvi).var); + } + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID e; + if (g->arity() == 0) + e = enforced.get_local(g); + else + e = enforced.get_local(g, (*cvi).var->function_of()); + h.update_coef(e, (*cvi).coef); + break; + } + default: + assert(0); + } + h.update_const((*gi).get_const()); + } + + // add floor definition involving variables appeared in bounds + while (!floor_geq_stack.empty()) { + std::pair p = floor_geq_stack.top(); + floor_geq_stack.pop(); + + GEQ_Handle h1 = f_root->add_GEQ(); + GEQ_Handle h2 = f_root->add_GEQ(); + for (Constr_Vars_Iter cvi(p.first); cvi; cvi++) { + switch ((*cvi).var->kind()) { + case Input_Var: { + int pos = (*cvi).var->get_position(); + h1.update_coef(enforced.input_var(pos), (*cvi).coef); + h2.update_coef(enforced.input_var(pos), -(*cvi).coef); + break; + } + case Exists_Var: + case Wildcard_Var: { + std::map::iterator p2 = exists_mapping.find((*cvi).var); + Variable_ID e; + if (p2 == exists_mapping.end()) { + e = fe->declare(); + exists_mapping[(*cvi).var] = e; + } + else + e = (*p2).second; + h1.update_coef(e, (*cvi).coef); + h2.update_coef(e, -(*cvi).coef); + + if (floor_var_set.find((*cvi).var) == floor_var_set.end()) { + GEQ_Handle h3; + findFloorInequality(b, (*cvi).var, h3, v); + floor_geq_stack.push(std::make_pair(h3, (*cvi).var)); + floor_var_set.insert((*cvi).var); + } + break; + } + case Global_Var: { + Global_Var_ID g = (*cvi).var->get_global_var(); + Variable_ID e; + if (g->arity() == 0) + e = enforced.get_local(g); + else + e = enforced.get_local(g, (*cvi).var->function_of()); + h1.update_coef(e, (*cvi).coef); + h2.update_coef(e, -(*cvi).coef); + break; + } + default: + assert(0); + } + } + h1.update_const(p.first.get_const()); + h2.update_const(-p.first.get_const()); + h2.update_const(-p.first.get_coef(p.second)-1); + } + enforced.simplify(); + + CG_outputRepr *stRepr = NULL; + if (step != 1) + stRepr = ocg->CreateInt(abs(step)); + CG_outputRepr *indexRepr = outputIdent(ocg, b, v, assigned_on_the_fly); + CG_outputRepr *ctrlRepr = ocg->CreateInductive(indexRepr, lbRepr, ubRepr, stRepr); + + return std::make_pair(ctrlRepr, true); + } +} + + +Relation project_onto_levels(Relation R, int last_level, bool wildcards) { + assert(last_level >= 0 && R.is_set() && last_level <= R.n_set()); + if (last_level == R.n_set()) return R; + + int orig_vars = R.n_set(); + int num_projected = orig_vars - last_level; + R = Extend_Set(R,num_projected + ); // Project out vars numbered > last_level + Mapping m1 = Mapping::Identity(R.n_set()); // now orig_vars+num_proj + + for(int i=last_level+1; i <= orig_vars; i++) { + m1.set_map(Set_Var, i, Exists_Var, i); + m1.set_map(Set_Var, i+num_projected, Set_Var, i); + } + + MapRel1(R, m1, Comb_Id); + R.finalize(); + R.simplify(); + if (!wildcards) + R = Approximate(R,1); + assert(R.is_set()); + return R; +} + + +// Check if the lower bound already enforces the stride by +// (Where m is coef of v in g and L is the bound on m*v): +// Check if m divides L evenly and Check if this l.bound on v implies strideEQ +bool boundHitsStride(const GEQ_Handle &g, Variable_ID v, + const EQ_Handle &strideEQ, + coef_t /*stride*/, // currently unused + Relation known) { +/* m = coef of v in g; + L = bound on v part of g; +*/ + // Check if m divides L evenly + coef_t m = g.get_coef(v); + Relation test(known.n_set()); + F_Exists *e = test.add_exists(); // g is "L >= mv" + Variable_ID alpha = e->declare(); // want: "l = m alpha" + F_And *a = e->add_and(); + EQ_Handle h = a->add_EQ(); + for(Constr_Vars_Iter I(g,false); I; I++) + if((*I).var != v) { + if((*I).var->kind() != Global_Var) + h.update_coef((*I).var, (*I).coef); + else + h.update_coef(test.get_local((*I).var->get_global_var()), (*I).coef); + } + + h.update_const(g.get_const()); + h.update_coef(alpha,m); // set alpha's coef to m + if (!(Gist(test,copy(known)).is_obvious_tautology())) + return false; + // Check if this lower bound on v implies the strideEQ + Relation boundRel = known; // want: "known and l = m v" + boundRel.and_with_EQ(g); // add in l = mv + Relation strideRel(known.n_set()); + strideRel.and_with_EQ(strideEQ); + return Gist(strideRel, boundRel).is_obvious_tautology(); +} + + +// // Return true if there are no variables in g except wildcards & v +bool isSimpleStride(const EQ_Handle &g, Variable_ID v) { + EQ_Handle gg = g; // should not be necessary, but iterators are + // a bit brain-dammaged + bool is_simple=true; + for(Constr_Vars_Iter cvi(gg, false); cvi && is_simple; cvi++) + is_simple = ((*cvi).coef == 0 || (*cvi).var == v + || (*cvi).var->kind() == Wildcard_Var); + return is_simple; +} + + +int countStrides(Conjunct *c, Variable_ID v, EQ_Handle &strideEQ, + bool &simple) { + int strides=0; + for(EQ_Iterator G(c); G; G++) + for(Constr_Vars_Iter I(*G, true); I; I++) + if (((*I).coef != 0) && (*G).get_coef(v) != 0) { + strides++; + simple = isSimpleStride(*G,v); + strideEQ = *G; + break; + } + return strides; +} + +namespace { + +bool hasEQ(Relation r, int level) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(EQ_Iterator G(s_conj); G; G++) + if ((*G).get_coef(v)) + return true; + return false; +} + + + +static Relation pickEQ(Relation r, int level) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(EQ_Iterator E(s_conj); E; E++) + if ((*E).get_coef(v)) { + Relation test_rel(r.n_set()); + test_rel.and_with_EQ(*E); + return test_rel; + } + assert(0); + return r; +} + +/* pickBound will return an EQ as a GEQ if it finds one */ +Relation pickBound(Relation r, int level, int UB) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + if ((UB && (*G).get_coef(v) < 0) + || (!UB && (*G).get_coef(v) > 0) ) { + Relation test_rel(r.n_set()); + test_rel.and_with_GEQ(*G); + return test_rel; + } + } + for(EQ_Iterator E(s_conj); E; E++) { + if ((*E).get_coef(v)) { + Relation test_rel(r.n_set()); + test_rel.and_with_GEQ(*E); + if ((UB && (*E).get_coef(v) > 0) + || (!UB && (*E).get_coef(v) < 0) ) + test_rel = Complement(test_rel); + return test_rel; + } + } + assert(0); + return r; +} + +} + +Relation pickOverhead(Relation r, int liftTo) { + r.simplify(); + Conjunct *s_conj = r.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + Relation test_rel(r.n_set()); + test_rel.and_with_GEQ(*G); + Variable_ID v; + coef_t pos = -1; + coef_t c= 0; + for(Constr_Vars_Iter cvi(*G, false); cvi; cvi++) + if ((*cvi).coef && (*cvi).var->kind() == Input_Var + && (*cvi).var->get_position() > pos) { + v = (*cvi).var; + pos = (*cvi).var->get_position(); + c = (*cvi).coef; + } +#if 0 + fprintf(DebugFile,"Coef = %d, constraint = %s\n", + c,(const char *)test_rel.print_formula_to_string()); +#endif + return test_rel; + } + for(EQ_Iterator E(s_conj); E; E++) { + assert(liftTo >= 1); + int pos = max((*E).max_tuple_pos(),max_fs_arity(*E)+1); + +/* Pick stride constraints only when the variables with stride are outer + loop variables */ + if ((*E).has_wildcards() && pos < liftTo) { + Relation test_rel(r.n_set()); + test_rel.and_with_EQ(*E); + return test_rel; + } + else if (!(*E).has_wildcards() && pos <= liftTo) { + Relation test_rel(r.n_set()); + test_rel.and_with_EQ(*E); + test_rel.simplify(); + test_rel = EQs_to_GEQs(test_rel,true); + return pickOverhead(test_rel,liftTo); + } + } + if (code_gen_debug>1) { + fprintf(DebugFile,"Could not find overhead:\n"); + r.prefix_print(DebugFile); + } + return Relation::True(r.n_set()); +} + + + +bool hasBound(Relation r, int level, int UB) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(GEQ_Iterator G(s_conj); G; G++) { + if (UB && (*G).get_coef(v) < 0) return true; + if (!UB && (*G).get_coef(v) > 0) return true; + } + for(EQ_Iterator E(s_conj); E; E++) { + if ((*E).get_coef(v)) return true; + } + return false; +} + +bool find_any_constraint(int s, int level, Relation &kr, int direction, + Relation &S, bool approx) { + /* If we don't intersect I with restrictions, the combination + of S and restrictions can be unsatisfiable, which means that + the new split node gets pruned away and we still don't have + finite bounds -> infinite recursion. */ + + Relation I = projected_nIS[level][s]; + I = Gist(I,copy(kr)); + if(approx) I = Approximate(I); + if (hasBound(I,level,direction)) { + Relation pickfrom; + if(has_nonstride_EQ(I,level)) + pickfrom = pickEQ(I,level); + else + pickfrom = pickBound(I,level,direction); + S = pickOverhead(pickfrom,level); + if(S.is_obvious_tautology()) S = Relation::Null(); + return !S.is_null(); + } + return false; +} + + +bool has_nonstride_EQ(Relation r, int level) { + r.simplify(); + Variable_ID v = set_var(level); + Conjunct *s_conj = r.single_conjunct(); + for(EQ_Iterator G(s_conj); G; G++) + if ((*G).get_coef(v) && !(*G).has_wildcards()) + return true; + return false; +} + + +Relation minMaxOverhead(Relation r, int level) { + r.finalize(); + r.simplify(); + Conjunct *s_conj = r.single_conjunct(); + GEQ_Handle LBs[50],UBs[50]; + int numLBs = 0; + int numUBs = 0; + Variable_ID v = set_var(level); + for(GEQ_Iterator G(s_conj); G; G++) if ((*G).get_coef(v)) { + GEQ_Handle g = *G; + if (g.get_coef(v) > 0) LBs[numLBs++] = g; + else UBs[numUBs++] = g; + } + if (numLBs <= 1 && numUBs <= 1) { + return Relation::True(r.n_set()); + } + Relation r1(r.n_set()); + Relation r2(r.n_set()); + if (numLBs > 1) { + // remove a max in lower bound + r1.and_with_GEQ(LBs[0]); + r2.and_with_GEQ(LBs[1]); + r1 = project_onto_levels(Difference(r1,r2),level-1,0); + } + else { + // remove a min in upper bound + r1.and_with_GEQ(UBs[0]); + r2.and_with_GEQ(UBs[1]); + r1 = project_onto_levels(Difference(r1,r2),level-1,0); + } +#if 0 + fprintf(DebugFile,"Testing %s\n",(const char *)r1.print_formula_to_string()); + fprintf(DebugFile,"will removed overhead on bounds of t%d: %s\n",level, + (const char *)r.print_formula_to_string()); +#endif + + return pickOverhead(r1, -1); +} + +std::pair find_simplest_assignment(const Relation &R_, Variable_ID v, const std::vector &assigned_on_the_fly) { + Relation &R = const_cast(R_); + Conjunct *c = R.single_conjunct(); + + int min_cost = INT_MAX; + EQ_Handle eq; + for (EQ_Iterator ei(c->EQs()); ei; ei++) + if (!(*ei).has_wildcards() && (*ei).get_coef(v) != 0) { + int cost = 0; + + if (abs((*ei).get_coef(v)) != 1) + cost += 4; // divide cost + + int num_var = 0; + for (Constr_Vars_Iter cvi(*ei); cvi; cvi++) + if ((*cvi).var != v) { + num_var++; + if ((*cvi).var->kind() == Global_Var && (*cvi).var->get_global_var()->arity() > 0) { + cost += 10; // function cost + } + if (abs((*cvi).coef) != 1) + cost += 2; // multiply cost + if ((*cvi).var->kind() == Input_Var && assigned_on_the_fly[(*cvi).var->get_position()-1] != NULL) { + cost += 5; // substituted variable cost + } + } + if ((*ei).get_const() != 0) + num_var++; + if (num_var > 1) + cost += num_var - 1; // addition cost + + if (cost < min_cost) { + min_cost = cost; + eq = *ei; + } + } + + return std::make_pair(eq, min_cost); +} + +int max_fs_arity(const Constraint_Handle &c) { + int max_arity=0; + for(Constr_Vars_Iter cv(c); cv; cv++) + if((*cv).var->kind() == Global_Var) + max_arity = max(max_arity,(*cv).var->get_global_var()->arity()); + return max_arity; +} + +} diff --git a/omega/code_gen/src/rose_attributes.cc b/omega/code_gen/src/rose_attributes.cc new file mode 100644 index 0000000..bb9681c --- /dev/null +++ b/omega/code_gen/src/rose_attributes.cc @@ -0,0 +1,183 @@ +#include + +namespace omega { + +CodeInsertionAttribute* getOrCreateCodeInsertionAttribute(SgNode* node) { + CodeInsertionAttribute* attr; + if(node->attributeExists("code_insertion")) + return static_cast(node->getAttribute("code_insertion")); + attr = new CodeInsertionAttribute(); + node->setAttribute("code_insertion", attr); + return attr; +} + +void postProcessRoseCodeInsertion(SgProject* proj) { + //generatePDF(*proj); + CodeInsertionVisitor visitor = CodeInsertionVisitor(); + visitor.initialize(); + visitor.traverseInputFiles(proj); + visitor.insertCode(); +} + +// Swap a code insertion from one node (sn) to another (dn) +// -- note that this function does not currently remove the insertion from the sn node +void moveCodeInsertion(SgNode* sn, CodeInsertion* ci, SgNode* dn) { + CodeInsertionAttribute* new_attr; + // TODO in the near future: replace the above statement with 'new_attr = getOrCreateCodeInsertionAttribute(...)' + CodeInsertionAttribute* old_attr = static_cast(sn->getAttribute("code_insertion")); + if(dn->attributeExists("code_insertion")) { + new_attr = static_cast(dn->getAttribute("code_insertion")); + } + else { + new_attr = new CodeInsertionAttribute(); + dn->setAttribute("code_insertion", new_attr); + } + new_attr->add(ci); +} + +// A function that copies a specific attribute from one node to another +// this function exists to get around a ROSE limitation that does not +// copy attributes +void copyAttribute(std::string attr_name, SgNode* s, SgNode* d) { + if(s->attributeExists(attr_name)) { + d->setAttribute(attr_name,s->getAttribute(attr_name)); + } +} + +// TODO: find all existng attributes and iterate over them instead of doing them +// individually +void copyAttributes(SgNode* s, SgNode* d) { + copyAttribute("code_insertion", s, d); + //...any other attributes... +} + +void CodeInsertionVisitor::initialize() { + this->loop_level = 0; + this->ci_marks = std::vector(); +} + +void CodeInsertionVisitor::markStmt(SgStatement* stmt, CodeInsertion* ci) { + // this check prevents multiple copies of stmts + // -- may be changed in the future + if(!ci->marked) { + CodeInsertionMark* pos = new CodeInsertionMark(); + pos->stmt = stmt; + pos->ci = ci; + this->ci_marks.push_back(pos); + ci->marked = true; + } +} + +// increase loop_level as the visitor descends +void CodeInsertionVisitor::preOrderVisit(SgNode* n) { + if (isSgForStatement(n)) { + this->loop_level++; + } +} + +void CodeInsertionVisitor::postOrderVisit(SgNode* n) { + if(isSgForStatement(n)) { + this->loop_level--; + } + if(isSgStatement(n)) { + if(n->attributeExists("code_insertion")) { + CodeInsertionAttribute *attr = static_cast(n->getAttribute("code_insertion")); + for(CodeInsertionPtrListItr itr = attr->begin(); itr != attr->end(); ++itr) { + CodeInsertion *insertion = *itr; + // check loop level -- if it is equivelent, mark statement for insertion + // -- else, move attribute up to parent + if(insertion->loop_level != this->loop_level) { + moveCodeInsertion(n, insertion, n->get_parent()); + } + else { + this->markStmt(isSgStatement(n), insertion); + } + } + } + } +} + +// final stage of algorithm that inserts marked statements +void CodeInsertionVisitor::insertCode() { + for(std::vector::iterator itr = this->ci_marks.begin(); itr != this->ci_marks.end(); ++itr) { + CodeInsertionMark* mark = *itr; + SgScopeStatement* scope = static_cast(mark->stmt->get_parent()); + SageInterface::insertStatementBefore(mark->stmt, mark->ci->getStatement(scope)); + } +} + +SgStatement* PragmaInsertion::getStatement(SgScopeStatement* scopeStmt) { + SgStatement* stmt = SageBuilder::buildPragmaDeclaration(this->name); + return stmt; +} + +//SgStatement* MMPrefetchInsertion::getStatement(SgScopeStatement* scopeStmt) { +// const SgName& name = SgName("_mm_prefetch"); +// SgType* rtype = SageBuilder::buildVoidType(); +// SgExpression* arr_arg = SageBuilder::buildVarRefExp(this->arrName); +// SgExpression* hint_arg = SageBuilder::buildShortVal(this->cacheHint); +// SgExprListExp* args = SageBuilder::buildExprListExp(arr_arg,hint_arg); +// SgStatement* stmt = SageBuilder::buildFunctionCallStmt(name, rtype, args, scopeStmt); +// return stmt; +//} + +SgStatement* MMPrefetchInsertion::getStatement(SgScopeStatement* scopeStmt) { + const SgName fname = SgName("_mm_prefetch"); + SgType* rtype = SageBuilder::buildVoidType(); + SgExpression* arr_arg = this->buildArrArg(scopeStmt); + SgExpression* hint_arg = SageBuilder::buildShortVal(this->cacheHint); + SgExprListExp* args = SageBuilder::buildExprListExp(arr_arg, hint_arg); + return SageBuilder::buildFunctionCallStmt(fname, rtype, args, scopeStmt); +} + +SgExpression* MMPrefetchInsertion::buildArrArg(SgScopeStatement* scopeStmt) { + // if there are no index arguments given, just return a variable reference + if(this->indexCount == 0) { + const SgName aname = SgName(this->arrName); + return SageBuilder::buildVarRefExp(aname, scopeStmt); + } + std::vector argList = std::vector(); + // foreach dimension + for(int i = 0; i < this->indexCount; i++) { + argList.push_back(this->makeIndexExp(i, scopeStmt)); + } + return SageBuilder::buildExprListExp(argList); +} + +SgExpression* MMPrefetchInsertion::makeIndexExp(int dim, SgScopeStatement* scopeStmt) { + //(i + offset) or (offset) or (i) + std::string* indexer = this->indecies.at(dim); + int offset = this->offsets.at(dim); + if(indexer == NULL) { + return SageBuilder::buildIntVal(offset); + } + else { + const SgName name = SgName(*indexer); + SgVarRefExp* iref = SageBuilder::buildVarRefExp(name, scopeStmt); + if(offset == 0) { + return iref; + } + else { + return SageBuilder::buildAddOp(iref, SageBuilder::buildIntVal(offset)); + } + } +} + +void MMPrefetchInsertion::initialize(const std::string& arrName, int hint) { + this->arrName = std::string(arrName); + this->cacheHint = hint; + this->indecies = std::vector(); + this->offsets = std::vector(); + this->indexCount = 0; +} +void MMPrefetchInsertion::addDim(int offset) { + this->offsets.push_back(offset); + this->indecies.push_back(NULL); + this->indexCount++; +} +void MMPrefetchInsertion::addDim(int offset, const std::string& indexer) { + this->offsets.push_back(offset); + this->indecies.push_back(new std::string(indexer)); + this->indexCount++; +} +} diff --git a/omega/code_gen/src/tags b/omega/code_gen/src/tags new file mode 100644 index 0000000..a69c38b --- /dev/null +++ b/omega/code_gen/src/tags @@ -0,0 +1,158 @@ +!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/ +!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/ +!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/ +!_TAG_PROGRAM_NAME Exuberant Ctags // +!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/ +!_TAG_PROGRAM_VERSION 5.8 // +CG_split CG.cc /^CG_split::CG_split(IntTuple &active, int lvl, const Relation &cond_, CG_result *T, CG_result *F) { $/;" f class:omega::CG_split +CG_stringRepr CG_stringRepr.cc /^CG_stringRepr::CG_stringRepr() {$/;" f class:omega::CG_stringRepr +CG_stringRepr CG_stringRepr.cc /^CG_stringRepr::CG_stringRepr(const std::string& _s) : s(_s) {$/;" f class:omega::CG_stringRepr +CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::CG_suifRepr(): tnl_(NULL), op_() {$/;" f class:omega::CG_suifRepr +CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::CG_suifRepr(operand op): tnl_(NULL), op_(op) {$/;" f class:omega::CG_suifRepr +CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::CG_suifRepr(tree_node_list *tnl): tnl_(tnl),op_() {$/;" f class:omega::CG_suifRepr +CreateAnd CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateAnd(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateAnd CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateAnd(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateAssignment CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateAssignment(int indent, $/;" f class:omega::CG_stringBuilder +CreateAssignment CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateAssignment(int, CG_outputRepr *lhs,$/;" f class:omega::CG_suifBuilder +CreateComment CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateComment(int indent, const std::string &commentText) const {$/;" f class:omega::CG_stringBuilder +CreateComment CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateComment(int, const std::string &commentText) const {$/;" f class:omega::CG_suifBuilder +CreateEQ CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateEQ(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateEQ CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateEQ(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateGE CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateGE(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateGE CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateGE(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateIdent CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIdent(const std::string &_s) const {$/;" f class:omega::CG_stringBuilder +CreateIdent CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIdent(const std::string &_s) const {$/;" f class:omega::CG_suifBuilder +CreateIf CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIf(int indent, CG_outputRepr* guardList,$/;" f class:omega::CG_stringBuilder +CreateIf CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIf(int, CG_outputRepr *guardList,$/;" f class:omega::CG_suifBuilder +CreateInductive CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateInductive(CG_outputRepr* index,$/;" f class:omega::CG_stringBuilder +CreateInductive CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateInductive(CG_outputRepr *index,$/;" f class:omega::CG_suifBuilder +CreateInt CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateInt(int _i) const {$/;" f class:omega::CG_stringBuilder +CreateInt CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateInt(int _i) const {$/;" f class:omega::CG_suifBuilder +CreateIntegerCeil CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIntegerCeil(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateIntegerDivide CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIntegerDivide(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateIntegerDivide CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIntegerDivide(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateIntegerMod CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateIntegerMod(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateIntegerMod CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateIntegerMod(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateInvoke CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateInvoke(const std::string &fname,$/;" f class:omega::CG_stringBuilder +CreateInvoke CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateInvoke(const std::string &fname,$/;" f class:omega::CG_suifBuilder +CreateLE CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateLE(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateLE CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateLE(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateLoop CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateLoop(int indent, CG_outputRepr* control,$/;" f class:omega::CG_stringBuilder +CreateLoop CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateLoop(int, CG_outputRepr *control,$/;" f class:omega::CG_suifBuilder +CreateMinus CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateMinus(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateMinus CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateMinus(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreatePlaceHolder CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreatePlaceHolder(int indent, CG_outputRepr *stmt,$/;" f class:omega::CG_stringBuilder +CreatePlaceHolder CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreatePlaceHolder (int, CG_outputRepr *stmt,$/;" f class:omega::CG_suifBuilder +CreatePlus CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreatePlus(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreatePlus CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreatePlus(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +CreateTimes CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::CreateTimes(CG_outputRepr* lop, CG_outputRepr* rop) const {$/;" f class:omega::CG_stringBuilder +CreateTimes CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::CreateTimes(CG_outputRepr *lop,$/;" f class:omega::CG_suifBuilder +Dump CG_stringRepr.cc /^void CG_stringRepr::Dump() const {$/;" f class:omega::CG_stringRepr +Dump CG_suifRepr.cc /^void CG_suifRepr::Dump() const {$/;" f class:omega::CG_suifRepr +DumpToFile CG_stringRepr.cc /^void CG_stringRepr::DumpToFile(FILE *fp) const {$/;" f class:omega::CG_stringRepr +DumpToFile CG_suifRepr.cc /^void CG_suifRepr::DumpToFile(FILE *fp) const {$/;" f class:omega::CG_suifRepr +GetCode CG_suifRepr.cc /^tree_node_list* CG_suifRepr::GetCode() const {$/;" f class:omega::CG_suifRepr +GetExpression CG_suifRepr.cc /^operand CG_suifRepr::GetExpression() const {$/;" f class:omega::CG_suifRepr +GetIndentSpaces CG_stringBuilder.cc /^std::string GetIndentSpaces(int indent) {$/;" f namespace:omega +GetString CG_stringBuilder.cc /^std::string GetString(CG_outputRepr* repr) {$/;" f namespace:omega +GetString CG_stringRepr.cc /^std::string CG_stringRepr::GetString() const { $/;" f class:omega::CG_stringRepr +JunkStaticInit code_gen.cc /^class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} };$/;" c namespace:omega file: +JunkStaticInit code_gen.cc /^class JunkStaticInit{ public: JunkStaticInit(){ checkLoopLevel=0; fillInBounds=false;} };$/;" f class:omega::JunkStaticInit +MMGenerateCode code_gen.cc /^CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, $/;" f namespace:omega +MMGenerateCode code_gen.cc /^CG_outputRepr* MMGenerateCode(CG_outputBuilder* ocg, RelTuple &T, SetTuple &old_IS, const Tuple &stmt_content, Relation &known, int effort) {$/;" f namespace:omega +MMGenerateCode code_gen.cc /^std::string MMGenerateCode(RelTuple &T, SetTuple &old_IS, Relation &known, int effort) {$/;" f namespace:omega +SafeguardString CG_stringBuilder.cc /^static std::string SafeguardString(const std::string &s, char op) {$/;" f namespace:omega +StmtListAppend CG_stringBuilder.cc /^CG_outputRepr* CG_stringBuilder::StmtListAppend(CG_outputRepr* list1, CG_outputRepr* list2) const {$/;" f class:omega::CG_stringBuilder +StmtListAppend CG_suifBuilder.cc /^CG_outputRepr* CG_suifBuilder::StmtListAppend(CG_outputRepr *list1, $/;" f class:omega::CG_suifBuilder +boundHitsStride output_repr.cc /^bool boundHitsStride(const GEQ_Handle &g, Variable_ID v,$/;" f namespace:omega +checkLoopLevel code_gen.cc /^int checkLoopLevel;$/;" m namespace:omega file: +clear CG_suifRepr.cc /^void CG_suifRepr::clear() {$/;" f class:omega::CG_suifRepr +clone CG_stringRepr.cc /^CG_outputRepr* CG_stringRepr::clone() {$/;" f class:omega::CG_stringRepr +clone CG_suifRepr.cc /^CG_outputRepr* CG_suifRepr::clone() {$/;" f class:omega::CG_suifRepr +code_gen_debug code_gen.cc /^int code_gen_debug=0;$/;" m namespace:omega file: +countStrides output_repr.cc /^int countStrides(Conjunct *c, Variable_ID v, EQ_Handle &strideEQ, $/;" f namespace:omega +create_stride_on_bound output_repr.cc /^Relation create_stride_on_bound(int n, const std::map &lb, coef_t stride) {$/;" f namespace:omega::__anon2 +exit_code_gen CG_suifBuilder.cc /^void exit_code_gen(void) {$/;" f namespace:omega +extract_function_symbols code_gen.cc /^RelTuple extract_function_symbols(SetTuple &sets) {$/;" f namespace:omega +fillInBounds code_gen.cc /^bool fillInBounds;$/;" m namespace:omega file: +filter_function_symbols code_gen.cc /^SetTuple filter_function_symbols(SetTuple &sets, bool keep_fs){$/;" f namespace:omega +findFloorInequality output_repr.cc /^bool findFloorInequality(Relation &r, Variable_ID v, GEQ_Handle &h, Variable_ID excluded) {$/;" f namespace:omega +findOverhead CG.cc /^Relation CG_leaf::findOverhead(int liftTo) {$/;" f class:omega::CG_leaf +findOverhead CG.cc /^Relation CG_loop::findOverhead(int liftTo) {$/;" f class:omega::CG_loop +findOverhead CG.cc /^Relation CG_split::findOverhead(int liftTo) {$/;" f class:omega::CG_split +find_any_constraint output_repr.cc /^bool find_any_constraint(int s, int level, Relation &kr, int direction,$/;" f namespace:omega +find_simplest_assignment output_repr.cc /^std::pair find_simplest_assignment(const Relation &R_, Variable_ID v, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +force_finite_bounds CG.cc /^CG_result * CG_loop::force_finite_bounds() {$/;" f class:omega::CG_loop +force_finite_bounds CG.cc /^CG_result * CG_split::force_finite_bounds() {$/;" f class:omega::CG_split +gen_recursive code_gen.cc /^CG_result *gen_recursive(int level, IntTuple &isActive) {$/;" f namespace:omega +get_stride output_repr.cc /^void get_stride(const Constraint_Handle &h, Variable_ID &wc, coef_t &step){$/;" f namespace:omega::__anon1 +greatest_common_step output_repr.cc /^Relation greatest_common_step(const Tuple &I, const Tuple &active, int level, const Relation &known) {$/;" f namespace:omega +hasBound output_repr.cc /^bool hasBound(Relation r, int level, int UB) {$/;" f namespace:omega +hasEQ output_repr.cc /^bool hasEQ(Relation r, int level) {$/;" f namespace:omega::__anon3 +has_nonstride_EQ output_repr.cc /^bool has_nonstride_EQ(Relation r, int level) {$/;" f namespace:omega +hoistGuard CG.cc /^Relation CG_leaf::hoistGuard() {$/;" f class:omega::CG_leaf +hoistGuard CG.cc /^Relation CG_loop::hoistGuard() {$/;" f class:omega::CG_loop +hoistGuard CG.cc /^Relation CG_split::hoistGuard() {$/;" f class:omega::CG_split +init_code_gen CG_suifBuilder.cc /^void init_code_gen(int&, char* []) {$/;" f namespace:omega +isSimpleStride output_repr.cc /^bool isSimpleStride(const EQ_Handle &g, Variable_ID v) {$/;" f namespace:omega +junkInitInstance__ code_gen.cc /^static JunkStaticInit junkInitInstance__;$/;" m namespace:omega file: +k_ocg_comment CG_suifBuilder.cc /^char *k_ocg_comment;$/;" m namespace:omega file: +last_level code_gen.cc /^int last_level;\/\/ Should not be global, but it is.$/;" m namespace:omega file: +libcode_gen_suif_string CG_suifBuilder.cc /^const char *libcode_gen_suif_string = "";$/;" m namespace:omega file: +libcode_gen_ver_string CG_suifBuilder.cc /^const char *libcode_gen_ver_string = "";$/;" m namespace:omega file: +libcode_gen_who_string CG_suifBuilder.cc /^const char *libcode_gen_who_string = "";$/;" m namespace:omega file: +liftOverhead CG.cc /^CG_result * CG_loop::liftOverhead(int depth) {$/;" f class:omega::CG_loop +liftOverhead CG.cc /^CG_result * CG_split::liftOverhead(int depth) {$/;" f class:omega::CG_split +loopIdxNames code_gen.cc /^Tuple< Tuple > loopIdxNames;\/\/per stmt$/;" m namespace:omega file: +lowerBoundForLevel code_gen.cc /^int lowerBoundForLevel;$/;" m namespace:omega file: +max_fs_arity output_repr.cc /^int max_fs_arity(const Constraint_Handle &c) {$/;" f namespace:omega +minMaxOverhead output_repr.cc /^Relation minMaxOverhead(Relation r, int level) {$/;" f namespace:omega +new_IS code_gen.cc /^SetTuple new_IS;$/;" m namespace:omega file: +omega CG.cc /^namespace omega {$/;" n file: +omega CG_stringBuilder.cc /^namespace omega {$/;" n file: +omega CG_stringRepr.cc /^namespace omega {$/;" n file: +omega CG_suifBuilder.cc /^namespace omega {$/;" n file: +omega CG_suifRepr.cc /^namespace omega {$/;" n file: +omega code_gen.cc /^namespace omega {$/;" n file: +omega output_repr.cc /^namespace omega {$/;" n file: +outputAssignment output_repr.cc /^std::pair outputAssignment(CG_outputBuilder *ocg, const Relation &R_, Variable_ID v, Relation &enforced, CG_outputRepr *&if_repr, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +outputBounds output_repr.cc /^std::pair outputBounds(CG_outputBuilder* ocg, const Relation &bounds, Variable_ID v, int indent, Relation &enforced, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +outputEasyBoundAsRepr output_repr.cc /^CG_outputRepr* outputEasyBoundAsRepr(CG_outputBuilder* ocg, Relation &bounds,$/;" f namespace:omega +outputGuard output_repr.cc /^CG_outputRepr *outputGuard(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +outputIdent output_repr.cc /^CG_outputRepr* outputIdent(CG_outputBuilder* ocg, const Relation &R_, Variable_ID v, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +outputLBasRepr output_repr.cc /^CG_outputRepr *outputLBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, $/;" f namespace:omega +outputStatement output_repr.cc /^CG_outputRepr* outputStatement(CG_outputBuilder *ocg, CG_outputRepr *stmt, int indent, const Relation &mapping_, const Relation &known_, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +outputSubstitution output_repr.cc /^Tuple outputSubstitution(CG_outputBuilder* ocg, const Relation &R_, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +outputUBasRepr output_repr.cc /^CG_outputRepr *outputUBasRepr(CG_outputBuilder* ocg, const GEQ_Handle &g, $/;" f namespace:omega +output_EQ_strides output_repr.cc /^CG_outputRepr *output_EQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +output_GEQ_strides output_repr.cc /^CG_outputRepr *output_GEQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +output_as_guard output_repr.cc /^CG_outputRepr* output_as_guard(CG_outputBuilder* ocg, const Relation &guards_in, Constraint_Handle e, bool is_equality, const std::vector &assigned_on_the_fly) {$/;" f namespace:omega +pickBound output_repr.cc /^Relation pickBound(Relation r, int level, int UB) {$/;" f namespace:omega::__anon3 +pickEQ output_repr.cc /^static Relation pickEQ(Relation r, int level) {$/;" f namespace:omega::__anon3 +pickOverhead output_repr.cc /^Relation pickOverhead(Relation r, int liftTo) {$/;" f namespace:omega +print CG.cc /^std::string CG_result::print(int indent) {$/;" f class:omega::CG_result +printRepr CG.cc /^CG_outputRepr* CG_leaf::printRepr(CG_outputBuilder* ocg, int indent, const std::vector &assigned_on_the_fly) {$/;" f class:omega::CG_leaf +printRepr CG.cc /^CG_outputRepr* CG_loop::printRepr(CG_outputBuilder* ocg, int indent, const std::vector &assigned_on_the_fly) {$/;" f class:omega::CG_loop +printRepr CG.cc /^CG_outputRepr* CG_split::printRepr(CG_outputBuilder* ocg, int indent, const std::vector &assigned_on_the_fly) {$/;" f class:omega::CG_split +printStructure CG.cc /^std::string CG_leaf::printStructure(int) {$/;" f class:omega::CG_leaf +printStructure CG.cc /^std::string CG_loop::printStructure(int indent) {$/;" f class:omega::CG_loop +printStructure CG.cc /^std::string CG_split::printStructure(int indent) {$/;" f class:omega::CG_split +project_onto_levels output_repr.cc /^Relation project_onto_levels(Relation R, int last_level, bool wildcards) {$/;" f namespace:omega +projected_nIS code_gen.cc /^SetTupleTuple projected_nIS;$/;" m namespace:omega file: +recompute CG.cc /^CG_result * CG_loop::recompute(const Relation &k, const Relation &r) {$/;" f class:omega::CG_loop +recompute CG.cc /^CG_result * CG_split::recompute(const Relation &k, const Relation &r) {$/;" f class:omega::CG_split +recompute CG.cc /^CG_result* CG_leaf::recompute(const Relation &k, const Relation &r) {$/;" f class:omega::CG_leaf +removeGuard CG.cc /^void CG_leaf::removeGuard() {$/;" f class:omega::CG_leaf +smtNonSplitLevels code_gen.cc /^Tuple< IntTuple > smtNonSplitLevels;$/;" m namespace:omega file: +statementInfo code_gen.cc /^Tuple statementInfo;$/;" m namespace:omega file: +stmtForLoopCheck code_gen.cc /^int stmtForLoopCheck;$/;" m namespace:omega file: +strip_function_symbols code_gen.cc /^RelTuple strip_function_symbols(SetTuple &sets) {$/;" f namespace:omega +substitute CG_suifBuilder.cc /^bool substitute(instruction *in, var_sym *sym, operand expr, base_symtab *st) {$/;" f namespace:omega +substitute CG_suifBuilder.cc /^bool substitute(tree_node *tn, var_sym *sym, operand expr, base_symtab *st) {$/;" f namespace:omega +substitute CG_suifBuilder.cc /^bool substitute(tree_node_list *tnl, var_sym *sym, operand expr,$/;" f namespace:omega +syncs code_gen.cc /^std::vector< std::pair > syncs;$/;" m namespace:omega file: +transformations code_gen.cc /^RelTuple transformations;$/;" m namespace:omega file: +upperBoundForLevel code_gen.cc /^int upperBoundForLevel;$/;" m namespace:omega file: +var_substitution_threshold output_repr.cc /^int var_substitution_threshold = 4;$/;" m namespace:omega file: +~CG_stringRepr CG_stringRepr.cc /^CG_stringRepr::~CG_stringRepr() {$/;" f class:omega::CG_stringRepr +~CG_suifRepr CG_suifRepr.cc /^CG_suifRepr::~CG_suifRepr() {$/;" f class:omega::CG_suifRepr -- cgit v1.2.3-70-g09d2