Merge branch 'master' into doe

16 files changed, 43628 insertions, 0 deletions

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 <omega/Relation.h>
+#include <basic/boolset.h>
+#include <code_gen/CG_outputBuilder.h>
+#include <vector>
+
+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<CG_result *, Relation> 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<CG_outputRepr *> &stmts, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const = 0;
+  CG_outputRepr *printRepr(CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &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<Relation> restrictions_;
+  std::vector<CG_result *> clauses_;
+
+  CG_split(CodeGen *codegen, const BoolSet<> &active, const std::vector<Relation> &restrictions, const std::vector<CG_result *> &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<CG_result *, Relation> liftOverhead(int depth, bool propagate_up);
+  Relation hoistGuard();
+  void removeGuard(const Relation &guard);
+  CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const;
+  CG_result *clone() const;
+  void dump(int indent) const;
+
+private:
+  std::vector<CG_result *> 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<CG_result *, Relation> liftOverhead(int depth, bool propagate_up);
+  Relation hoistGuard();
+  void removeGuard(const Relation &guard);
+  CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const;
+  CG_outputRepr *printRepr(bool do_print_guard, int indent, CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly) const;
+  CG_result *clone() const;
+  void dump(int indent) const;
+};
+
+
+
+struct CG_leaf: public CG_result {
+  Relation known_;
+  std::map<int, Relation> 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<CG_result *, Relation> liftOverhead(int depth, bool propagate_up);
+  Relation hoistGuard();
+  void removeGuard(const Relation &guard);
+  CG_outputRepr *printRepr(int indent, CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts, const std::vector<std::pair<CG_outputRepr *, int> > &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 <code_gen/CG_outputRepr.h>
+
+#include <string>
+#include <vector>
+
+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<std::string> &vars,
+                                               std::vector<CG_outputRepr *> &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<CG_outputRepr *> &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 <basic/Tuple.h>
+#include <code_gen/rose_attributes.h>
+#include <code_gen/CG_outputBuilder.h>
+#include <code_gen/CG_roseRepr.h>
+#include <string>
+
+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<CG_outputRepr*> &funcList,
+  //                                         Tuple<std::string> &loop_vars) const;
+
+
+  //---------------------------------------------------------------------------
+  // substitute variables in stmt
+  //---------------------------------------------------------------------------
+
+
+ 
+   CG_outputRepr *CreateSubstitutedStmt(int indent, CG_outputRepr *stmt,
+                                               const std::vector<std::string> &vars,
+                                               std::vector<CG_outputRepr *> &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<CG_outputRepr *> &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::vector<SgVarRefExp *>substitute(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 <code_gen/CG_outputRepr.h>
+#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 <code_gen/CG_outputBuilder.h>
+#include <code_gen/CG_stringRepr.h>
+
+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<std::string> &vars, std::vector<CG_outputRepr *> &subs) const;
+  CG_stringRepr *CreateAssignment(int indent, CG_outputRepr *lhs, CG_outputRepr *rhs) const;
+  CG_stringRepr *CreateInvoke(const std::string &funcName, std::vector<CG_outputRepr *> &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 <code_gen/CG_outputRepr.h>
+#include <string>
+#include <iostream>
+
+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 <basic/Tuple.h>
+#include <code_gen/CG_outputBuilder.h>
+#include <code_gen/CG_suifRepr.h>
+#include <string>
+
+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<CG_outputRepr*> &funcList,
+                                           Tuple<std::string> &loop_vars) const;
+  CG_outputRepr* CreateAssignment(int indent, CG_outputRepr* lhs,
+                                  CG_outputRepr* rhs) const;
+  CG_outputRepr* CreateInvoke(const std::string &fname,
+                              Tuple<CG_outputRepr*> &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 <code_gen/CG_outputRepr.h>
+#include <suif1.h>
+
+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 <omega.h>
+#include <code_gen/CG_outputBuilder.h>
+#include <basic/boolset.h>
+#include <vector>
+#include <set>
+#include <map>
+
+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<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly, std::set<Variable_ID> excluded_floor_vars = std::set<Variable_ID>());
+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<std::pair<CG_outputRepr *, int> > &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<std::pair<CG_outputRepr *, int> > &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<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly);
+
+CG_outputRepr *output_ident(CG_outputBuilder *ocg, const Relation &R, Variable_ID v, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly);
+std::pair<CG_outputRepr *, std::pair<CG_outputRepr *, int> > output_assignment(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly);
+CG_outputRepr *output_loop(CG_outputBuilder *ocg, const Relation &R, int level, const Relation &known, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly);
+CG_outputRepr *output_guard(CG_outputBuilder *ocg, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly);
+std::vector<CG_outputRepr *> output_substitutions(CG_outputBuilder *ocg, const Relation &R, const std::vector<std::pair<CG_outputRepr *, int> > &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<EQ_Handle, int> find_simplest_assignment(const Relation &R, Variable_ID v, const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly = std::vector<std::pair<CG_outputRepr *, int> >());
+std::pair<bool, GEQ_Handle> find_floor_definition(const Relation &R, Variable_ID v, std::set<Variable_ID> excluded_floor_vars = std::set<Variable_ID>());
+std::pair<EQ_Handle, Variable_ID> 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<Variable_ID, Variable_ID> &exists_mapping);
+
+Relation pick_one_guard(const Relation &R, int level = 0);
+CG_outputRepr *leaf_print_repr(BoolSet<> active, const std::map<int, Relation> &guards,
+                               CG_outputRepr *guard_repr, const Relation &known,
+                               int indent, CG_outputBuilder *ocg, const std::vector<int> &remap,
+                               const std::vector<Relation> &xforms, const std::vector<CG_outputRepr *> &stmts,
+                               const std::vector<std::pair<CG_outputRepr *, int> > &assigned_on_the_fly);
+CG_outputRepr *loop_print_repr(const std::vector<CG_loop *> &loops, int start, int end,
+                               const Relation &guard, CG_outputRepr *guard_repr,
+                               int indent, CG_outputBuilder *ocg, const std::vector<CG_outputRepr *> &stmts,
+                               const std::vector<std::pair<CG_outputRepr *, int> > &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 <basic/Tuple.h>
+#include <omega/Relation.h>
+#include <code_gen/CG.h>
+#include <code_gen/CG_outputRepr.h>
+#include <code_gen/CG_outputBuilder.h>
+
+namespace omega {
+
+typedef Tuple<int> IntTuple;
+typedef Tuple<Relation> SetTuple;
+typedef Tuple<SetTuple> SetTupleTuple;
+typedef Tuple<Relation> RelTuple;
+typedef Tuple<RelTuple> RelTupleTuple;
+
+CG_outputRepr *MMGenerateCode(CG_outputBuilder* ocg,
+                              Tuple<Relation> &T, Tuple<Relation> &old_IS,
+                              const Tuple<CG_outputRepr *> &stmt_content,
+                              Relation &known, int effort=1);
+std::string MMGenerateCode(Tuple<Relation> &T, Tuple<Relation> &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<CG_outputRepr *> &stmt_content, Relation &known,
+		Tuple< IntTuple >& smtNonSplitLevels_,
+	       	std::vector< std::pair<int, std::string> > syncs_,
+	       	const Tuple< Tuple<std::string> >& loopIdxNames_, 
+	       	int effort=1);
+//end-protonu
+
+struct Polyhedra {
+  int last_level;
+  Tuple<Relation> transformations;
+  Relation known;
+
+  Tuple<int> remap;  // after initial iteration space's disjoint set splitting, the new statement number maps to old statement number
+  Tuple<Tuple<Relation> > projected_nIS;
+ 
+  Polyhedra(const Tuple<Relation> &T, const Tuple<Relation> &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 <omega/Relation.h>
+#include <code_gen/CG.h>
+#include <code_gen/CG_outputBuilder.h>
+#include <vector>
+#include <string>
+
+namespace omega {
+
+class CodeGen {
+public:
+  static const std::string loop_var_name_prefix;
+  static const int var_substitution_threshold;
+  
+protected:
+  std::vector<std::vector<Relation> > projected_IS_; // projected_IS_[level-1][new stmt#]
+  std::vector<Relation> xforms_;  // transformations[original stmt#]
+  Relation known_; // no need to generate code for constraints satisfied in known
+  std::vector<int> remap_; // map new stmt# to original stmt#
+
+public:
+  CodeGen(const std::vector<Relation> &xforms, const std::vector<Relation> &IS, const Relation &known = Relation::Null(),
+		                 std::vector< std::vector<int > > smtNonSplitLevels_ =   std::vector< std::vector<int > >(),
+		                 std::vector< std::vector<std::string> > loopIdxNames_ =  std::vector< std::vector<std::string> >(),
+		                 std::vector< std::pair<int, std::string> >  syncs_ =    std::vector< std::pair<int, std::string> >()
+		         );
+  ~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 <stdexcept>
+
+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à!
+defšed
+(
+AÌ—dy_šþuded_cg
+)
+
+2 

+	#AÌ—dy_šþuded_cg
+
+
+	)
+
+4 
+	~<basic/Tu¶e.h
+>
+
+5 
+	~<omega/R–©iÚ.h
+>
+
+6 
+	~<code_g’/CG_¡ršgBužd”.h
+>
+
+7 
+	~<code_g’/CG_¡ršgR•r.h
+>
+
+8 
+	~<veùÜ
+>
+
+10 
+Çme¥aû
+ 
+	gomega
+ {
+
+12 
+	gTu¶e
+<> 
+	tIÁTu¶e
+;
+
+13 
+	gTu¶e
+<
+	tR–©iÚ
+> 
+	tS‘Tu¶e
+;
+
+14 
+	gTu¶e
+<
+	tS‘Tu¶e
+> 
+	tS‘Tu¶eTu¶e
+;
+
+15 
+	gTu¶e
+<
+	tR–©iÚ
+> 
+	tR–Tu¶e
+;
+
+17 þas 
+	cCG_»suÉ
+ {
+
+18 
+	gpublic
+:
+
+19 
+Tu¶e
+<> 
+isAùive
+;
+
+20 
+	gËv–
+;
+
+21 
+R–©iÚ
+ 
+	g»¡riùiÚs
+;
+
+22 
+R–©iÚ
+ 
+	gknown
+;
+
+24 
+	gpublic
+:
+
+25 
+CG_»suÉ
+() {}
+
+26 
+vœtu®
+ ~
+CG_»suÉ
+() {}
+
+28 
+vœtu®
+ 
+CG_»suÉ
+ *
+þÚe
+() = 0;
+
+29 
+vœtu®
+ 
+d•th
+() = 0;
+
+30 
+vœtu®
+ 
+boÞ
+ 
+isNuÎ
+(è{  
+	gçl£
+;};
+
+31 
+vœtu®
+ 
+CG_»suÉ
+ *
+liáOv”h—d
+(
+d•th
+) = 0;
+
+32 
+vœtu®
+ 
+R–©iÚ
+ 
+fšdOv”h—d
+(
+liáTo
+) = 0;
+
+33 
+vœtu®
+ 
+CG_»suÉ
+ *
+fÜû_fš™e_bounds
+() = 0;
+
+34 
+vœtu®
+ 
+R–©iÚ
+ 
+hoi¡Gu¬d
+() = 0;
+
+35 
+vœtu®
+ 
+»moveGu¬d
+() = 0;
+
+36 
+vœtu®
+ 
+CG_»suÉ
+ *
+»compu‹
+(cÚ¡ 
+R–©iÚ
+ &
+k
+, cÚ¡ R–©iÚ &
+r
+) = 0;
+
+38 
+vœtu®
+ 
+CG_ou�utR•r
+ *
+´štR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, 
+šd’t
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+) = 0;
+
+39 
+vœtu®
+ 
+	g¡d
+::
+¡ršg
+ 
+´štSŒuùu»
+(
+šd’t
+) = 0;
+
+40 
+vœtu®
+ 
+	g¡d
+::
+¡ršg
+ 
+´št
+(
+šd’t
+);
+
+44 þas 
+	cCG_nuÎ
+ : 
+public
+ 
+CG_»suÉ
+ {
+
+45 
+public
+:
+
+46 
+CG_»suÉ
+ *
+þÚe
+() {
+
+47  
+Ãw
+ 
+CG_nuÎ
+;
+
+49 
+	g¡d
+::
+¡ršg
+ 
+´štSŒuùu»
+() {
+
+52 
+CG_ou�utR•r
+ *
+´štR•r
+(
+CG_ou�utBužd”
+*, , cÚ¡ 
+¡d
+::
+veùÜ
+<CG_outputRepr *> &)
+
+53 {  (
+CG_ou�utR•r
+ *)0; };
+
+55 
+d•th
+() {  0; }
+
+56 
+boÞ
+ 
+isNuÎ
+(è{  
+	gŒue
+;};
+
+57 
+CG_»suÉ
+ *
+»compu‹
+(cÚ¡ 
+R–©iÚ
+ &, const Relation &) {
+
+58  
+	gthis
+;
+
+60 
+CG_»suÉ
+ *
+liáOv”h—d
+() {
+
+61  
+	gthis
+;
+
+63 
+R–©iÚ
+ 
+fšdOv”h—d
+() {
+
+64  
+	gR–©iÚ
+::
+True
+(1);
+
+66 
+CG_»suÉ
+ *
+fÜû_fš™e_bounds
+(è{  
+	gthis
+; };
+
+67 
+R–©iÚ
+ 
+hoi¡Gu¬d
+(è{  
+	gR–©iÚ
+::
+True
+(1); }
+
+68 
+»moveGu¬d
+() { }
+
+73 þas 
+	cCG_¥l™
+ : 
+public
+ 
+CG_»suÉ
+ {
+
+74 
+public
+:
+
+75 
+CG_»suÉ
+ *
+ŒueCÏu£
+,*
+	gçl£CÏu£
+;
+
+76 
+R–©iÚ
+ 
+	gcÚd™iÚ
+;
+
+77 
+R–©iÚ
+ 
+	ggu¬d
+;
+
+79 
+	gpublic
+:
+
+80 
+CG_¥l™
+(
+IÁTu¶e
+ &
+aùive
+, 
+lvl
+, cÚ¡ 
+R–©iÚ
+ &
+cÚd_
+, 
+CG_»suÉ
+ *
+T
+, CG_»suÉ *
+F
+);
+
+81 ~
+CG_¥l™
+(è{ 
+d–‘e
+ 
+	gŒueCÏu£
+; d–‘�
+	gçl£CÏu£
+; }
+
+83 
+CG_»suÉ
+ *
+þÚe
+() {
+
+84 
+R–©iÚ
+ 
+	gc
+ = 
+cÚd™iÚ
+;
+
+85  
+Ãw
+ 
+CG_¥l™
+(
+isAùive
+,
+Ëv–
+,
+c
+,
+
+86 
+ŒueCÏu£
+->
+þÚe
+(),
+çl£CÏu£
+->clone());
+
+88 
+d•th
+()
+
+89 {  
+max
+(
+ŒueCÏu£
+->
+d•th
+(),
+çl£CÏu£
+->depth()); }
+
+90 
+	g¡d
+::
+¡ršg
+ 
+´štSŒuùu»
+(
+šd’t
+);
+
+91 
+CG_ou�utR•r
+ *
+´štR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, 
+šd’t
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+93 
+CG_»suÉ
+ *
+liáOv”h—d
+(
+d•th
+);
+
+94 
+CG_»suÉ
+ *
+fÜû_fš™e_bounds
+();
+
+95 
+R–©iÚ
+ 
+fšdOv”h—d
+(
+liáTo
+);
+
+96 
+CG_»suÉ
+ *
+»compu‹
+(cÚ¡ 
+R–©iÚ
+ &
+k
+, cÚ¡ R–©iÚ &
+r
+);
+
+97 
+R–©iÚ
+ 
+hoi¡Gu¬d
+();
+
+98 
+»moveGu¬d
+(è{ 
+	ggu¬d
+ = 
+R–©iÚ
+::
+True
+(
+cÚd™iÚ
+.
+n_£t
+()); }
+
+104 þas 
+	cCG_Ëaf
+ : 
+public
+ 
+CG_»suÉ
+ {
+
+105 
+public
+:
+
+106 
+S‘Tu¶e
+ 
+gu¬d
+;
+
+108 
+	gpublic
+:
+
+109 
+CG_Ëaf
+(
+IÁTu¶e
+ &
+aùive
+) {
+
+110 
+isAùive
+ = 
+aùive
+;
+
+111 
+	ggu¬d
+.
+»®loÿ‹
+(
+isAùive
+.
+size
+());
+
+113 ~
+CG_Ëaf
+() {}
+
+115 
+CG_»suÉ
+ *
+þÚe
+() {
+
+116  
+Ãw
+ 
+CG_Ëaf
+(
+isAùive
+);
+
+118 
+CG_»suÉ
+ *
+liáOv”h—d
+() {
+
+119  
+	gthis
+;
+
+121 
+CG_»suÉ
+ *
+fÜû_fš™e_bounds
+() {
+
+122  
+	gthis
+;
+
+124 
+R–©iÚ
+ 
+fšdOv”h—d
+(
+liáTo
+);
+
+125 
+	g¡d
+::
+¡ršg
+ 
+´štSŒuùu»
+(
+šd’t
+);
+
+126 
+CG_ou�utR•r
+ *
+´štR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, 
+šd’t
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+127 
+d•th
+() {  0; }
+
+128 
+CG_»suÉ
+ *
+»compu‹
+(cÚ¡ 
+R–©iÚ
+ &
+k
+, cÚ¡ R–©iÚ &
+r
+);
+
+129 
+R–©iÚ
+ 
+hoi¡Gu¬d
+();
+
+130 
+»moveGu¬d
+();
+
+133 þas 
+	cCG_loÝ
+ : 
+public
+ 
+CG_»suÉ
+ {
+
+134 
+public
+:
+
+135 
+R–©iÚ
+ 
+bounds
+;
+
+136 
+R–©iÚ
+ 
+	ggu¬d
+;
+
+137 
+boÞ
+ 
+	gÃedLoÝ
+;
+
+138 
+CG_»suÉ
+ *
+	gbody
+;
+
+140 
+	gpublic
+:
+
+141 
+CG_loÝ
+(
+IÁTu¶e
+ &
+aùive
+, 
+lvl
+, 
+CG_»suÉ
+ *
+b
+) {
+
+142 
+	gisAùive
+ = 
+aùive
+;
+
+143 
+	gËv–
+ = 
+lvl
+;
+
+144 
+	gbody
+ = 
+b
+;
+
+146 ~
+CG_loÝ
+(è{ 
+d–‘e
+ 
+	gbody
+; }
+
+148 
+CG_»suÉ
+ *
+þÚe
+() {
+
+149  
+Ãw
+ 
+CG_loÝ
+(
+isAùive
+,
+Ëv–
+,
+body
+->
+þÚe
+());
+
+151 
+R–©iÚ
+ 
+fšdOv”h—d
+(
+liáTo
+);
+
+152 
+CG_»suÉ
+ *
+fÜû_fš™e_bounds
+();
+
+153 
+CG_»suÉ
+ *
+liáOv”h—d
+(
+d•th
+);
+
+154 
+	g¡d
+::
+¡ršg
+ 
+´štSŒuùu»
+(
+šd’t
+);
+
+155 
+CG_ou�utR•r
+ *
+´štR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, 
+šd’t
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+156 
+d•th
+(è{  (
+	gÃedLoÝ
+?1:0)+
+body
+->depth(); }
+
+157 
+CG_»suÉ
+ *
+»compu‹
+(cÚ¡ 
+R–©iÚ
+ &
+k
+, cÚ¡ R–©iÚ &
+r
+);
+
+158 
+R–©iÚ
+ 
+hoi¡Gu¬d
+();
+
+159 
+»moveGu¬d
+(è{ 
+	ggu¬d
+ = 
+R–©iÚ
+::
+True
+(
+bounds
+.
+n_£t
+()); }
+
+	@CG_outputBuilder.h
+
+21 #iâdeà
+CG_ou�utBužd”_h
+
+
+22 

+	#CG_ou�utBužd”_h
+
+
+	)
+
+24 
+	~<code_g’/CG_ou�utR•r.h
+>
+
+25 
+	~<basic/Tu¶e.h
+>
+
+26 
+	~<¡ršg
+>
+
+28 
+Çme¥aû
+ 
+	gomega
+ {
+
+30 þas 
+	cCG_ou�utBužd”
+ {
+
+31 
+	gpublic
+:
+
+32 
+CG_ou�utBužd”
+() {}
+
+33 
+vœtu®
+ ~
+CG_ou�utBužd”
+() {}
+
+38 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©ePÏûHÞd”
+(
+šd’t
+, CG_ou�utR•¸*
+¡mt
+,
+
+39 
+Tu¶e
+<
+CG_ou�utR•r
+*> &
+funcLi¡
+,
+
+40 
+Tu¶e
+<
+¡d
+::
+¡ršg
+> &
+loÝ_v¬s
+) const = 0;
+
+45 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eAssignm’t
+(
+šd’t
+, CG_ou�utR•r* 
+lhs
+,
+
+46 
+CG_ou�utR•r
+* 
+rhs
+) const = 0;
+
+51 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eInvoke
+(cÚ¡ 
+¡d
+::
+¡ršg
+ &
+âame
+,
+
+52 
+Tu¶e
+<
+CG_ou�utR•r
+*> &
+¬gLi¡
+) const = 0;
+
+57 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eComm’t
+(
+šd’t
+,
+
+58 cÚ¡ 
+¡d
+::
+¡ršg
+ &
+comm’tText
+) const = 0;
+
+63 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eIf
+(
+šd’t
+, CG_ou�utR•r* 
+gu¬dCÚd™iÚ
+,
+
+64 
+CG_ou�utR•r
+* 
+Œue_¡mtLi¡
+,
+
+65 
+CG_ou�utR•r
+* 
+çl£_¡mtLi¡
+) const = 0;
+
+70 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eInduùive
+(CG_ou�utR•r* 
+šdex
+,
+
+71 
+CG_ou�utR•r
+* 
+low”
+,
+
+72 
+CG_ou�utR•r
+* 
+uµ”
+,
+
+73 
+CG_ou�utR•r
+* 
+¡•
+) const = 0;
+
+78 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eLoÝ
+(
+šd’t
+, CG_ou�utR•r* 
+cÚŒÞ
+,
+
+79 
+CG_ou�utR•r
+* 
+¡mtLi¡
+) const = 0;
+
+84 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eCÝy
+(CG_ou�utR•r* 
+Üigš®
+) const {
+
+85 ià(
+	gÜigš®
+ =ð
+NULL
+)
+
+86  
+NULL
+;
+
+88  
+	gÜigš®
+->
+þÚe
+();
+
+94 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eIÁ
+() const = 0;
+
+95 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eId’t
+(cÚ¡ 
+¡d
+::
+¡ršg
+ &
+idSŒ
+) const = 0;
+
+100 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©ePlus
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+101 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eMšus
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+102 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eTimes
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+117 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Divide
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+118 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Mod
+(CG_ou�utR•¸*
+lÝ
+, CG_ou�utR•¸*
+rÝ
+) const {
+
+119 
+CG_ou�utR•r
+ *
+	glÝ2
+ = 
+C»©eCÝy
+(
+lÝ
+);
+
+120 
+CG_ou�utR•r
+ *
+	grÝ2
+ = 
+C»©eCÝy
+(
+rÝ
+);
+
+121  
+C»©eMšus
+(
+lÝ2
+, 
+C»©eTimes
+(
+rÝ2
+, 
+C»©eIÁeg”Divide
+(
+lÝ
+, 
+rÝ
+)));
+
+123 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Cež
+(CG_ou�utR•r* 
+lÝ
+, CG_ou�utR•r* 
+rÝ
+) const {
+
+124  
+C»©eMšus
+(
+NULL
+, 
+C»©eIÁeg”Divide
+(C»©eMšus(NULL, 
+lÝ
+), 
+rÝ
+));
+
+130 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eAnd
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+135 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eGE
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+136 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eLE
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+137 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eEQ
+(CG_outputRepr*, CG_outputRepr*) const = 0;
+
+142 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+StmtLi¡Aµ’d
+(CG_ou�utR•r* 
+li¡1
+, CG_ou�utR•r* 
+li¡2
+) const = 0;
+
+	@CG_outputRepr.h
+
+16 #iâdeà
+CG_ou�utR•r_h
+
+
+17 

+	#CG_ou�utR•r_h
+
+
+	)
+
+19 
+	~<¡dio.h
+>
+
+20 
+	~<basic/Tu¶e.h
+>
+
+21 
+	~<¡ršg
+>
+
+23 
+Çme¥aû
+ 
+	gomega
+ {
+
+25 þas 
+	cCG_ou�utR•r
+ {
+
+26 
+	gpublic
+:
+
+27 
+vœtu®
+ ~
+CG_ou�utR•r
+() {};
+
+28 
+vœtu®
+ 
+CG_ou�utR•r
+ *
+þÚe
+() = 0;
+
+29 
+vœtu®
+ 
+þ—r
+() {};
+
+34 
+vœtu®
+ 
+Dump
+() const = 0;
+
+35 
+vœtu®
+ 
+DumpToFže
+(
+FILE
+ *
+å
+ = 
+¡d”r
+) const = 0;
+
+	@CG_stringBuilder.h
+
+1 #iâdeà
+CG_¡ršgBužd”_h
+
+
+2 

+	#CG_¡ršgBužd”_h
+
+
+	)
+
+4 
+	~<code_g’/CG_ou�utBužd”.h
+>
+
+5 
+	~<code_g’/CG_¡ršgR•r.h
+>
+
+7 
+Çme¥aû
+ 
+	gomega
+ {
+
+9 þas 
+	cCG_¡ršgBužd”
+: 
+public
+ 
+CG_ou�utBužd”
+ {
+
+10 
+public
+:
+
+11 
+CG_¡ršgBužd”
+() {}
+
+12 ~
+CG_¡ršgBužd”
+() {}
+
+14 
+CG_ou�utR•r
+* 
+C»©ePÏûHÞd”
+(
+šd’t
+, CG_ou�utR•¸*
+¡mt
+,
+
+15 
+Tu¶e
+<
+CG_ou�utR•r
+*> &
+funcLi¡
+,
+
+16 
+Tu¶e
+<
+¡d
+::
+¡ršg
+> &
+loÝ_v¬s
+) const;
+
+18 
+CG_ou�utR•r
+* 
+C»©eAssignm’t
+(
+šd’t
+, CG_ou�utR•r* 
+lhs
+,
+
+19 
+CG_ou�utR•r
+* 
+rhs
+) const;
+
+20 
+CG_ou�utR•r
+* 
+C»©eInvoke
+(cÚ¡ 
+¡d
+::
+¡ršg
+ &
+âame
+,
+
+21 
+Tu¶e
+<
+CG_ou�utR•r
+*> &
+¬gLi¡
+) const;
+
+22 
+CG_ou�utR•r
+* 
+C»©eComm’t
+(
+šd’t
+, cÚ¡ 
+¡d
+::
+¡ršg
+ &
+comm’tText
+) const;
+
+23 
+CG_ou�utR•r
+* 
+C»©eIf
+(
+šd’t
+, CG_ou�utR•r* 
+gu¬dCÚd™iÚ
+,
+
+24 
+CG_ou�utR•r
+* 
+Œue_¡mtLi¡
+, CG_ou�utR•r* 
+çl£_¡mtLi¡
+) const;
+
+25 
+CG_ou�utR•r
+* 
+C»©eInduùive
+(CG_ou�utR•r* 
+šdex
+,
+
+26 
+CG_ou�utR•r
+* 
+low”
+,
+
+27 
+CG_ou�utR•r
+* 
+uµ”
+,
+
+28 
+CG_ou�utR•r
+* 
+¡•
+) const;
+
+29 
+CG_ou�utR•r
+* 
+C»©eLoÝ
+(
+šd’t
+, CG_ou�utR•r* 
+cÚŒÞ
+,
+
+30 
+CG_ou�utR•r
+* 
+¡mtLi¡
+) const;
+
+31 
+CG_ou�utR•r
+* 
+C»©eIÁ
+() const;
+
+32 
+CG_ou�utR•r
+* 
+C»©eId’t
+(cÚ¡ 
+¡d
+::
+¡ršg
+ &
+idSŒ
+) const;
+
+33 
+CG_ou�utR•r
+* 
+C»©ePlus
+(CG_outputRepr*, CG_outputRepr*) const;
+
+34 
+CG_ou�utR•r
+* 
+C»©eMšus
+(CG_outputRepr*, CG_outputRepr*) const;
+
+35 
+CG_ou�utR•r
+* 
+C»©eTimes
+(CG_outputRepr*, CG_outputRepr*) const;
+
+36 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Divide
+(CG_outputRepr*, CG_outputRepr*) const;
+
+37 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Mod
+(CG_outputRepr*, CG_outputRepr*) const;
+
+38 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Cež
+(CG_outputRepr*, CG_outputRepr*) const;
+
+39 
+CG_ou�utR•r
+* 
+C»©eAnd
+(CG_outputRepr*, CG_outputRepr*) const;
+
+40 
+CG_ou�utR•r
+* 
+C»©eGE
+(CG_outputRepr*, CG_outputRepr*) const;
+
+41 
+CG_ou�utR•r
+* 
+C»©eLE
+(CG_outputRepr*, CG_outputRepr*) const;
+
+42 
+CG_ou�utR•r
+* 
+C»©eEQ
+(CG_outputRepr*, CG_outputRepr*) const;
+
+43 
+CG_ou�utR•r
+* 
+StmtLi¡Aµ’d
+(CG_ou�utR•r* 
+li¡1
+, CG_ou�utR•r* 
+li¡2
+) const;
+
+46 
+	g¡d
+::
+¡ršg
+ 
+G‘SŒšg
+(
+CG_ou�utR•r
+* 
+»´
+);
+
+47 
+	g¡d
+::
+¡ršg
+ 
+G‘Ind’tS·ûs
+(
+šd’t
+);
+
+	@CG_stringRepr.h
+
+1 #iâdeà
+CG_¡ršgR•r_h
+
+
+2 

+	#CG_¡ršgR•r_h
+
+
+	)
+
+4 
+	~<¡dio.h
+>
+
+5 
+	~<code_g’/CG_ou�utR•r.h
+>
+
+6 
+	~<¡ršg
+>
+
+8 
+Çme¥aû
+ 
+	gomega
+ {
+
+10 þas 
+	cCG_¡ršgR•r
+ : 
+public
+ 
+CG_ou�utR•r
+ {
+
+11 
+public
+:
+
+12 
+CG_¡ršgR•r
+();
+
+13 
+CG_¡ršgR•r
+(cÚ¡ 
+¡d
+::
+¡ršg
+& 
+_s
+);
+
+14 
+	gvœtu®
+ ~
+CG_¡ršgR•r
+();
+
+15 
+vœtu®
+ 
+CG_ou�utR•r
+ *
+þÚe
+();
+
+20 
+	g¡d
+::
+¡ršg
+ 
+G‘SŒšg
+() const;
+
+25 
+vœtu®
+ 
+Dump
+() const;
+
+26 
+vœtu®
+ 
+DumpToFže
+(
+FILE
+ *
+å
+ = 
+¡d”r
+) const;
+
+27 
+	g´iv©e
+:
+
+28 
+¡d
+::
+¡ršg
+ 
+s
+;
+
+	@CG_suifBuilder.h
+
+1 #iâdeà
+CG_suifBužd”_h
+
+
+2 

+	#CG_suifBužd”_h
+
+
+	)
+
+4 
+	~<basic/Tu¶e.h
+>
+
+5 
+	~<code_g’/CG_ou�utBužd”.h
+>
+
+6 
+	~<code_g’/CG_suifR•r.h
+>
+
+7 
+	~<¡ršg
+>
+
+9 
+Çme¥aû
+ 
+	gomega
+ {
+
+11 þas 
+	cCG_suifBužd”
+: 
+public
+ 
+CG_ou�utBužd”
+ {
+
+12 
+public
+:
+
+13 
+CG_suifBužd”
+(
+´oc_sym�b
+ *
+sym�b
+è{
+sym�b_
+ = symtab;}
+
+14 ~
+CG_suifBužd”
+() {}
+
+16 
+CG_ou�utR•r
+* 
+C»©ePÏûHÞd”
+(
+šd’t
+, CG_ou�utR•¸*
+¡mt
+,
+
+17 
+Tu¶e
+<
+CG_ou�utR•r
+*> &
+funcLi¡
+,
+
+18 
+Tu¶e
+<
+¡d
+::
+¡ršg
+> &
+loÝ_v¬s
+) const;
+
+19 
+CG_ou�utR•r
+* 
+C»©eAssignm’t
+(
+šd’t
+, CG_ou�utR•r* 
+lhs
+,
+
+20 
+CG_ou�utR•r
+* 
+rhs
+) const;
+
+21 
+CG_ou�utR•r
+* 
+C»©eInvoke
+(cÚ¡ 
+¡d
+::
+¡ršg
+ &
+âame
+,
+
+22 
+Tu¶e
+<
+CG_ou�utR•r
+*> &
+¬gLi¡
+) const;
+
+23 
+CG_ou�utR•r
+* 
+C»©eComm’t
+(
+šd’t
+, cÚ¡ 
+¡d
+::
+¡ršg
+ &
+comm’tText
+) const;
+
+24 
+CG_ou�utR•r
+* 
+C»©eIf
+(
+šd’t
+, CG_ou�utR•r* 
+gu¬dCÚd™iÚ
+,
+
+25 
+CG_ou�utR•r
+* 
+Œue_¡mtLi¡
+, CG_ou�utR•r* 
+çl£_¡mtLi¡
+) const;
+
+26 
+CG_ou�utR•r
+* 
+C»©eInduùive
+(CG_ou�utR•r* 
+šdex
+,
+
+27 
+CG_ou�utR•r
+* 
+low”
+,
+
+28 
+CG_ou�utR•r
+* 
+uµ”
+,
+
+29 
+CG_ou�utR•r
+* 
+¡•
+) const;
+
+30 
+CG_ou�utR•r
+* 
+C»©eLoÝ
+(
+šd’t
+, CG_ou�utR•r* 
+cÚŒÞ
+,
+
+31 
+CG_ou�utR•r
+* 
+¡mtLi¡
+) const;
+
+32 
+CG_ou�utR•r
+* 
+C»©eIÁ
+() const;
+
+33 
+CG_ou�utR•r
+* 
+C»©eId’t
+(cÚ¡ 
+¡d
+::
+¡ršg
+ &
+idSŒ
+) const;
+
+34 
+CG_ou�utR•r
+* 
+C»©ePlus
+(CG_outputRepr*, CG_outputRepr*) const;
+
+35 
+CG_ou�utR•r
+* 
+C»©eMšus
+(CG_outputRepr*, CG_outputRepr*) const;
+
+36 
+CG_ou�utR•r
+* 
+C»©eTimes
+(CG_outputRepr*, CG_outputRepr*) const;
+
+37 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Divide
+(CG_outputRepr*, CG_outputRepr*) const;
+
+38 
+CG_ou�utR•r
+* 
+C»©eIÁeg”Mod
+(CG_outputRepr*, CG_outputRepr*) const;
+
+39 
+CG_ou�utR•r
+* 
+C»©eAnd
+(CG_outputRepr*, CG_outputRepr*) const;
+
+40 
+CG_ou�utR•r
+* 
+C»©eGE
+(CG_outputRepr*, CG_outputRepr*) const;
+
+41 
+CG_ou�utR•r
+* 
+C»©eLE
+(CG_outputRepr*, CG_outputRepr*) const;
+
+42 
+CG_ou�utR•r
+* 
+C»©eEQ
+(CG_outputRepr*, CG_outputRepr*) const;
+
+43 
+CG_ou�utR•r
+* 
+StmtLi¡Aµ’d
+(CG_ou�utR•r* 
+li¡1
+, CG_ou�utR•r* 
+li¡2
+) const;
+
+47 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eP¿gma
+(
+šd’t
+, cÚ¡ 
+¡d
+::
+¡ršg
+ &
+´agmaText
+) const;
+
+52 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eDim3
+(
+immed
+ 
+v¬Name
+, immed 
+¬g1
+, immed 
+¬g2
+) const;
+
+53 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eDim3
+(
+immed
+ 
+v¬Name
+, immed 
+¬g1
+, immed 
+¬g2
+, immed 
+¬g3
+) const;
+
+59 
+vœtu®
+ 
+CG_ou�utR•r
+* 
+C»©eK”Ãl
+(
+immed_li¡
+* 
+iml
+) const;
+
+64 
+ty³_node
+* 
+ModifyTy³
+Ñy³_node* 
+ba£
+, cÚ¡ * 
+modif›r
+) const;
+
+65 
+	g´iv©e
+:
+
+66 
+´oc_sym�b
+ *
+sym�b_
+;
+
+69 
*
+k_ocg_comm’t
+;
+
+71 
+boÞ
+ 
+sub¡™u‹
+(
+š¡ruùiÚ
+ *
+š
+, 
+v¬_sym
+ *
+sym
+, 
+Ý”ªd
+ 
+ex´
+,
+
+72 
+ba£_sym�b
+ *
+¡
+=
+NULL
+);
+
+73 
+boÞ
+ 
+sub¡™u‹
+(
+Œ“_node
+ *
+Š
+, 
+v¬_sym
+ *
+sym
+, 
+Ý”ªd
+ 
+ex´
+,
+
+74 
+ba£_sym�b
+ *
+¡
+=
+NULL
+);
+
+75 
+boÞ
+ 
+sub¡™u‹
+(
+Œ“_node_li¡
+ *
+Šl
+, 
+v¬_sym
+ *
+sym
+, 
+Ý”ªd
+ 
+ex´
+,
+
+76 
+ba£_sym�b
+ *
+¡
+ = 
+NULL
+);
+
+	@CG_suifRepr.h
+
+1 #iâdeà
+CG_suifR•r_h
+
+
+2 

+	#CG_suifR•r_h
+
+
+	)
+
+4 
+	~<code_g’/CG_ou�utR•r.h
+>
+
+5 
+	~<suif1.h
+>
+
+7 
+Çme¥aû
+ 
+	gomega
+ {
+
+9 þas 
+	cCG_suifR•r
+ : 
+public
+ 
+CG_ou�utR•r
+ {
+
+10 
+ä›nd
+ 
+þass
+ 
+CG_suifBužd”
+;
+
+11 
+	gpublic
+:
+
+12 
+CG_suifR•r
+();
+
+13 
+CG_suifR•r
+(
+Œ“_node_li¡
+ *
+Šl
+);
+
+14 
+CG_suifR•r
+(
+Ý”ªd
+ 
+Ý
+);
+
+15 
+	gvœtu®
+ ~
+CG_suifR•r
+();
+
+16 
+vœtu®
+ 
+CG_ou�utR•r
+ *
+þÚe
+();
+
+17 
+vœtu®
+ 
+þ—r
+();
+
+19 
+Œ“_node_li¡
+* 
+G‘Code
+() const;
+
+20 
+Ý”ªd
+ 
+G‘Ex´essiÚ
+() const;
+
+25 
+vœtu®
+ 
+Dump
+() const;
+
+26 
+vœtu®
+ 
+DumpToFže
+(
+FILE
+ *
+å
+ = 
+¡d”r
+) const;
+
+27 
+	g´iv©e
+:
+
+30 
+Œ“_node_li¡
+ *
+Šl_
+;
+
+31 
+Ý”ªd
+ 
+	gÝ_
+;
+
+	@code_gen.h
+
+1 #ià!
+defšed
+(
+AÌ—dy_Inþuded_code_g’
+)
+
+2 

+	#AÌ—dy_Inþuded_code_g’
+
+
+	)
+
+4 
+	~<basic/Tu¶e.h
+>
+
+5 
+	~<omega/R–©iÚ.h
+>
+
+6 
+	~<code_g’/CG.h
+>
+
+7 
+	~<code_g’/CG_ou�utR•r.h
+>
+
+8 
+	~<code_g’/CG_ou�utBužd”.h
+>
+
+10 
+Çme¥aû
+ 
+	gomega
+ {
+
+12 
+	gTu¶e
+<> 
+	tIÁTu¶e
+;
+
+13 
+	gTu¶e
+<
+	tR–©iÚ
+> 
+	tS‘Tu¶e
+;
+
+14 
+	gTu¶e
+<
+	tS‘Tu¶e
+> 
+	tS‘Tu¶eTu¶e
+;
+
+15 
+	gTu¶e
+<
+	tR–©iÚ
+> 
+	tR–Tu¶e
+;
+
+16 
+	gTu¶e
+<
+	tR–Tu¶e
+> 
+	tR–Tu¶eTu¶e
+;
+
+18 
+CG_ou�utR•r
+ *
+MMG’”©eCode
+(
+CG_ou�utBužd”
+* 
+ocg
+,
+
+19 
+Tu¶e
+<
+R–©iÚ
+> &
+T
+, Tu¶e<R–©iÚ> &
+Þd_IS
+,
+
+20 cÚ¡ 
+Tu¶e
+<
+CG_ou�utR•r
+ *> &
+¡mt_cÚ‹Á
+,
+
+21 
+R–©iÚ
+ &
+known
+, 
+effÜt
+=1);
+
+22 
+	g¡d
+::
+¡ršg
+ 
+MMG’”©eCode
+(
+Tu¶e
+<
+R–©iÚ
+> &
+T
+, Tu¶e<R–©iÚ> &
+Þd_IS
+, R–©iÚ &
+known
+,
+
+23 
+effÜt
+=1);
+
+27 
+	sPÞyhed¿
+ {
+
+28 
+	gÏ¡_Ëv–
+;
+
+29 
+	gTu¶e
+<
+	gR–©iÚ
+> 
+	gŒªsfÜm©iÚs
+;
+
+30 
+R–©iÚ
+ 
+	gknown
+;
+
+32 
+	gTu¶e
+<> 
+	g»m­
+;
+
+33 
+	gTu¶e
+<Tu¶e<
+	gR–©iÚ
+> > 
+	g´ojeùed_nIS
+;
+
+35 
+PÞyhed¿
+(cÚ¡ 
+Tu¶e
+<
+R–©iÚ
+> &
+T
+, cÚ¡ Tu¶e<R–©iÚ> &
+Þd_IS
+, cÚ¡ R–©iÚ &
+known
+ = R–©iÚ::
+NuÎ
+());
+
+36 ~
+PÞyhed¿
+() {}
+
+	@output_repr.h
+
+1 #iâdeà
+OUTPUT_REPR_H
+
+
+2 

+	#OUTPUT_REPR_H
+
+
+	)
+
+4 
+	~<omega.h
+>
+
+5 
+	~<code_g’/CG_ou�utBužd”.h
+>
+
+6 
+	~<code_g’/CG_ou�utR•r.h
+>
+
+7 
+	~<veùÜ
+>
+
+8 
+	~<£t
+>
+
+10 
+Çme¥aû
+ 
+	gomega
+ {
+
+11 

+Ï¡_Ëv–
+;
+
+13 
+CG_ou�utR•r
+* 
+ou�utId’t
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+R
+, 
+V¬ŸbË_ID
+ 
+v
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+14 
+	g¡d
+::
+·œ
+<
+CG_ou�utR•r
+ *, 
+	gboÞ
+> 
+ou�utAssignm’t
+(
+CG_ou�utBužd”
+ *
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+R_
+, 
+V¬ŸbË_ID
+ 
+v
+, R–©iÚ &
+’fÜûd
+, CG_ou�utR•¸*&
+if_»´
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+15 
+	g¡d
+::
+·œ
+<
+CG_ou�utR•r
+ *, 
+	gboÞ
+> 
+ou�utBounds
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+bounds
+, 
+V¬ŸbË_ID
+ 
+v
+, 
+šd’t
+, R–©iÚ &
+’fÜûd
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+16 
+	gTu¶e
+<
+	gCG_ou�utR•r
+*> 
+ou�utSub¡™utiÚ
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+R
+, cÚ¡ 
+¡d
+::
+veùÜ
+<
+CG_ou�utR•r
+ *> &
+assigÃd_Ú_the_æy
+);
+
+17 
+CG_ou�utR•r
+* 
+ou�utS�‹m’t
+(
+CG_ou�utBužd”
+* 
+ocg
+, CG_ou�utR•¸*
+¡mt
+, 
+šd’t
+, cÚ¡ 
+R–©iÚ
+ &
+m­pšg
+, cÚ¡ R–©iÚ &
+known
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+18 
+CG_ou�utR•r
+* 
+ou�utGu¬d
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+gu¬ds_š
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+19 
+CG_ou�utR•r
+* 
+ou�ut_as_gu¬d
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+gu¬ds_š
+, 
+CÚ¡¿št_HªdË
+ 
+e
+, 
+boÞ
+ 
+is_equ®™y
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+20 
+CG_ou�utR•r
+* 
+ou�ut_EQ_¡rides
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+gu¬ds_š
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+21 
+CG_ou�utR•r
+* 
+ou�ut_GEQ_¡rides
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+R–©iÚ
+ &
+gu¬ds_š
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+22 
+CG_ou�utR•r
+ *
+ou�utLBasR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+GEQ_HªdË
+ &
+g
+, 
+R–©iÚ
+ &
+bounds
+, 
+V¬ŸbË_ID
+ 
+v
+, 
+cÛf_t
+ 
+¡ride
+, cÚ¡ 
+EQ_HªdË
+ &
+¡rideEQ
+, R–©iÚ 
+known
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+23 
+CG_ou�utR•r
+ *
+ou�utUBasR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, cÚ¡ 
+GEQ_HªdË
+ &
+g
+, 
+R–©iÚ
+ & 
+bounds
+, 
+V¬ŸbË_ID
+ 
+v
+,
+
+24 
+cÛf_t
+ ,
+
+25 cÚ¡ 
+EQ_HªdË
+ & ,
+
+26 cÚ¡ 
+¡d
+::
+veùÜ
+<
+CG_ou�utR•r
+ *> &
+assigÃd_Ú_the_æy
+ = std::veùÜ<CG_ou�utR•¸*>(
+Ï¡_Ëv–
+, 
+¡©ic_ÿ¡
+<CG_ou�utR•¸*>(
+NULL
+)));
+
+27 
+CG_ou�utR•r
+* 
+ou�utEasyBoundAsR•r
+(
+CG_ou�utBužd”
+* 
+ocg
+, 
+R–©iÚ
+ &
+bounds
+, cÚ¡ 
+CÚ¡¿št_HªdË
+ &
+g
+, 
+V¬ŸbË_ID
+ 
+v
+, 
+boÞ
+ 
+ignÜeWC
+, 
+ûžšg
+, cÚ¡ 
+¡d
+::
+veùÜ
+<CG_ou�utR•¸*> &
+assigÃd_Ú_the_æy
+);
+
+30 
+boÞ
+ 
+boundH™sSŒide
+(cÚ¡ 
+GEQ_HªdË
+ &
+g
+, 
+V¬ŸbË_ID
+ 
+v
+, cÚ¡ 
+EQ_HªdË
+ &
+¡rideEQ
+, 
+cÛf_t
+ , 
+R–©iÚ
+ 
+known
+);
+
+31 
+R–©iÚ
+ 
+g»©e¡_commÚ_¡•
+(cÚ¡ 
+Tu¶e
+<R–©iÚ> &
+I
+, cÚ¡ Tu¶e<> &
+aùive
+, 
+Ëv–
+, cÚ¡ R–©iÚ &
+known
+ = R–©iÚ::
+NuÎ
+());
+
+32 
+boÞ
+ 
+fšdFloÜIÃqu®™y
+(
+R–©iÚ
+ &
+r
+, 
+V¬ŸbË_ID
+ 
+v
+, 
+GEQ_HªdË
+ &
+h
+, V¬ŸbË_ID 
+exþuded
+);
+
+33 
+R–©iÚ
+ 
+´ojeù_Úto_Ëv–s
+(R–©iÚ 
+R
+, 
+Ï¡_Ëv–
+, 
+boÞ
+ 
+wždÿrds
+);
+
+34 
+boÞ
+ 
+isSim¶eSŒide
+(cÚ¡ 
+EQ_HªdË
+ &
+g
+, 
+V¬ŸbË_ID
+ 
+v
+);
+
+35 
+couÁSŒides
+(
+CÚjunù
+ *
+c
+, 
+V¬ŸbË_ID
+ 
+v
+, 
+EQ_HªdË
+ &
+¡rideEQ
+, 
+boÞ
+ &
+sim¶e
+);
+
+36 
+boÞ
+ 
+hasBound
+(
+R–©iÚ
+ 
+r
+, 
+Ëv–
+, 
+UB
+);
+
+37 
+boÞ
+ 
+fšd_ªy_cÚ¡¿št
+(
+s
+, 
+Ëv–
+, 
+R–©iÚ
+ &
+kr
+, 
+dœeùiÚ
+, R–©iÚ &
+S
+, boÞ 
+­´ox
+);
+
+38 
+boÞ
+ 
+has_nÚ¡ride_EQ
+(
+R–©iÚ
+ 
+r
+, 
+Ëv–
+);
+
+39 
+R–©iÚ
+ 
+pickOv”h—d
+(R–©iÚ 
+r
+, 
+liáTo
+);
+
+40 
+R–©iÚ
+ 
+mšMaxOv”h—d
+(R–©iÚ 
+r
+, 
+Ëv–
+);
+
+41 
+max_fs_ªy
+(cÚ¡ 
+CÚ¡¿št_HªdË
+ &
+c
+);
+
+	@/usr/include/stdio.h
+
+24 #iâdeà
+_STDIO_H
+
+
+26 #ià!
+defšed
+ 
+__Ãed_FILE
+ && !defšed 
+__Ãed___FILE
+
+
+27 

+	#_STDIO_H
+ 1
+
+	)
+
+28 
+	~<ã©u»s.h
+>
+
+30 
+	g__BEGIN_DECLS
+
+
+32 

+	#__Ãed_size_t
+
+
+	)
+
+33 

+	#__Ãed_NULL
+
+
+	)
+
+34 
+	~<¡ddef.h
+>
+
+36 
+	~<b™s/ty³s.h
+>
+
+37 

+	#__Ãed_FILE
+
+
+	)
+
+38 

+	#__Ãed___FILE
+
+
+	)
+
+42 #ià!
+defšed
+ 
+__FILE_defšed
+ && defšed 
+__Ãed_FILE
+
+
+45 
+	g_IO_FILE
+;
+
+47 
+__BEGIN_NAMESPACE_STD
+
+
+49 
+_IO_FILE
+ 
+	tFILE
+;
+
+50 
+	g__END_NAMESPACE_STD
+
+
+51 #ià
+defšed
+ 
+__USE_LARGEFILE64
+ || defšed 
+__USE_SVID
+ || defšed 
+__USE_POSIX
+ \
+
+52 || 
+defšed
+ 
+	g__USE_BSD
+ || defšed 
+	g__USE_ISOC99
+ || defšed 
+	g__USE_XOPEN
+ \
+
+53 || 
+defšed
+ 
+__USE_POSIX2
+
+
+54 
+	$__USING_NAMESPACE_STD
+(
+FILE
+)
+
+57 

+	#__FILE_defšed
+ 1
+
+	)
+
+59 #undeà
+__Ãed_FILE
+
+
+62 #ià!
+defšed
+ 
+____FILE_defšed
+ && defšed 
+__Ãed___FILE
+
+
+65 
+_IO_FILE
+ 
+	t__FILE
+;
+
+67 

+	#____FILE_defšed
+ 1
+
+	)
+
+69 #undeà
+__Ãed___FILE
+
+
+72 #ifdef 
+_STDIO_H
+
+
+73 

+	#_STDIO_USES_IOSTREAM
+
+
+	)
+
+75 
+	~<libio.h
+>
+
+77 #ifdeà
+__USE_XOPEN
+
+
+78 #ifdeà
+__GNUC__
+
+
+79 #iâdeà
+_VA_LIST_DEFINED
+
+
+80 
+_G_va_li¡
+ 
+	tva_li¡
+;
+
+81 

+	#_VA_LIST_DEFINED
+
+
+	)
+
+84 
+	~<¡d¬g.h
+>
+
+89 
+__BEGIN_NAMESPACE_STD
+
+
+90 #iâdeà
+__USE_FILE_OFFSET64
+
+
+91 
+_G_åos_t
+ 
+	tåos_t
+;
+
+93 
+_G_åos64_t
+ 
+	tåos_t
+;
+
+95 
+__END_NAMESPACE_STD
+
+
+96 #ifdeà
+__USE_LARGEFILE64
+
+
+97 
+_G_åos64_t
+ 
+	tåos64_t
+;
+
+101 

+	#_IOFBF
+ 0
+
+	)
+
+102 

+	#_IOLBF
+ 1
+
+	)
+
+103 

+	#_IONBF
+ 2
+
+	)
+
+107 #iâdeà
+BUFSIZ
+
+
+108 

+	#BUFSIZ
+ 
+_IO_BUFSIZ
+
+
+	)
+
+114 #iâdeà
+EOF
+
+
+115 

+	#EOF
+ (-1)
+
+	)
+
+121 

+	#SEEK_SET
+ 0
+
+	)
+
+122 

+	#SEEK_CUR
+ 1
+
+	)
+
+123 

+	#SEEK_END
+ 2
+
+	)
+
+126 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_XOPEN
+
+
+128 

+	#P_tmpdœ
+ "/tmp"
+
+	)
+
+141 
+	~<b™s/¡dio_lim.h
+>
+
+145 

+_IO_FILE
+ *
+¡dš
+;
+
+146 

+_IO_FILE
+ *
+¡dout
+;
+
+147 

+_IO_FILE
+ *
+¡d”r
+;
+
+149 

+	#¡dš
+ 
+¡dš
+
+
+	)
+
+150 

+	#¡dout
+ 
+¡dout
+
+
+	)
+
+151 

+	#¡d”r
+ 
+¡d”r
+
+
+	)
+
+153 
+__BEGIN_NAMESPACE_STD
+
+
+155 

+	$»move
+ (
+__cÚ¡
+ *
+__fž’ame
+è
+__THROW
+;
+
+157 

+	$Ȃme
+ (
+__cÚ¡
+ *
+__Þd
+, __cÚ¡ *
+__Ãw
+è
+__THROW
+;
+
+158 
+__END_NAMESPACE_STD
+
+
+160 #ifdeà
+__USE_ATFILE
+
+
+162 

+	$»Çm—t
+ (
+__Þdfd
+, 
+__cÚ¡
+ *
+__Þd
+, 
+__Ãwfd
+,
+
+163 
+__cÚ¡
+ *
+__Ãw
+è
+__THROW
+;
+
+166 
+__BEGIN_NAMESPACE_STD
+
+
+171 #iâdeà
+__USE_FILE_OFFSET64
+
+
+172 

+FILE
+ *
+	$tmpfže
+ (è
+__wur
+;
+
+174 #ifdeà
+__REDIRECT
+
+
+175 

+FILE
+ *
+	`__REDIRECT
+ (
+tmpfže
+, (), 
+tmpfže64
+è
+__wur
+;
+
+177 

+	#tmpfže
+ 
+tmpfže64
+
+
+	)
+
+181 #ifdeà
+__USE_LARGEFILE64
+
+
+182 

+FILE
+ *
+	$tmpfže64
+ (è
+__wur
+;
+
+186 
*
+	$tm²am
+ (*
+__s
+è
+__THROW
+ 
+__wur
+;
+
+187 
+__END_NAMESPACE_STD
+
+
+189 #ifdeà
+__USE_MISC
+
+
+192 
*
+	$tm²am_r
+ (*
+__s
+è
+__THROW
+ 
+__wur
+;
+
+196 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_XOPEN
+
+
+204 
*
+	$‹m²am
+ (
+__cÚ¡
+ *
+__dœ
+, __cÚ¡ *
+__pfx
+)
+
+205 
+__THROW
+ 
+__©Œibu‹_m®loc__
+ 
+__wur
+;
+
+209 
+__BEGIN_NAMESPACE_STD
+
+
+214 

+	`fþo£
+ (
+FILE
+ *
+__¡»am
+);
+
+219 

+	`fæush
+ (
+FILE
+ *
+__¡»am
+);
+
+220 
+__END_NAMESPACE_STD
+
+
+222 #ifdeà
+__USE_MISC
+
+
+229 

+	`fæush_uÆocked
+ (
+FILE
+ *
+__¡»am
+);
+
+232 #ifdeà
+__USE_GNU
+
+
+239 

+	`fþo£®l
+ ();
+
+243 
+__BEGIN_NAMESPACE_STD
+
+
+244 #iâdeà
+__USE_FILE_OFFSET64
+
+
+249 

+FILE
+ *
+	$fÝ’
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fž’ame
+,
+
+250 
+__cÚ¡
+ *
+__»¡riù
+ 
+__modes
+è
+__wur
+;
+
+255 

+FILE
+ *
+	$äeÝ’
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fž’ame
+,
+
+256 
+__cÚ¡
+ *
+__»¡riù
+ 
+__modes
+,
+
+257 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+259 #ifdeà
+__REDIRECT
+
+
+260 

+FILE
+ *
+	`__REDIRECT
+ (
+fÝ’
+, (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fž’ame
+,
+
+261 
+__cÚ¡
+ *
+__»¡riù
+ 
+__modes
+), 
+fÝ’64
+)
+
+262 
+__wur
+;
+
+263 

+FILE
+ *
+	`__REDIRECT
+ (
+äeÝ’
+, (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fž’ame
+,
+
+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ù
+ 
+__fž’ame
+,
+
+275 
+__cÚ¡
+ *
+__»¡riù
+ 
+__modes
+è
+__wur
+;
+
+276 

+FILE
+ *
+	$äeÝ’64
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fž’ame
+,
+
+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_funùiÚs_t
+ 
+__io_funcs
+è
+__THROW
+ 
+__wur
+;
+
+294 #ifdeà
+__USE_XOPEN2K8
+
+
+296 

+FILE
+ *
+	$fmemÝ’
+ (*
+__s
+, 
+size_t
+ 
+__Ën
+, 
+__cÚ¡
+ *
+__modes
+)
+
+297 
+__THROW
+ 
+__wur
+;
+
+302 

+FILE
+ *
+	$Ý’_mem¡»am
+ (**
+__buæoc
+, 
+size_t
+ *
+__siz–oc
+è
+__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 

+	$£tbufãr
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+, *__»¡riù 
+__buf
+,
+
+321 
+size_t
+ 
+__size
+è
+__THROW
+;
+
+324 

+	$£Žšebuf
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+328 
+__BEGIN_NAMESPACE_STD
+
+
+333 

+	`årštf
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+334 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+339 

+	`´štf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+341 

+	$¥rštf
+ (*
+__»¡riù
+ 
+__s
+,
+
+342 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__THROW
+;
+
+348 

+	`vårštf
+ (
+FILE
+ *
+__»¡riù
+ 
+__s
+, 
+__cÚ¡
+ *__»¡riù 
+__fÜm©
+,
+
+349 
+_G_va_li¡
+ 
+__¬g
+);
+
+354 

+	`v´štf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__¬g
+);
+
+356 

+	$v¥rštf
+ (*
+__»¡riù
+ 
+__s
+, 
+__cÚ¡
+ *__»¡riù 
+__fÜm©
+,
+
+357 
+_G_va_li¡
+ 
+__¬g
+è
+__THROW
+;
+
+358 
+__END_NAMESPACE_STD
+
+
+360 #ià
+defšed
+ 
+__USE_BSD
+ || defšed 
+__USE_ISOC99
+ || defšed 
+__USE_UNIX98
+
+
+361 
+__BEGIN_NAMESPACE_C99
+
+
+363 

+	$¢´štf
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__maxËn
+,
+
+364 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+365 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 3, 4)));
+
+367 

+	$v¢´štf
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__maxËn
+,
+
+368 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__¬g
+)
+
+369 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 3, 0)));
+
+370 
+__END_NAMESPACE_C99
+
+
+373 #ifdeà
+__USE_GNU
+
+
+376 

+	$va¥rštf
+ (**
+__»¡riù
+ 
+__±r
+, 
+__cÚ¡
+ *__»¡riù 
+__f
+,
+
+377 
+_G_va_li¡
+ 
+__¬g
+)
+
+378 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__´štf__
+, 2, 0))è
+__wur
+;
+
+379 

+	$__a¥rštf
+ (**
+__»¡riù
+ 
+__±r
+,
+
+380 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+381 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__´štf__
+, 2, 3))è
+__wur
+;
+
+382 

+	$a¥rštf
+ (**
+__»¡riù
+ 
+__±r
+,
+
+383 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+384 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__´štf__
+, 2, 3))è
+__wur
+;
+
+387 #ifdeà
+__USE_XOPEN2K8
+
+
+394 

+	$vd´štf
+ (
+__fd
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+,
+
+395 
+_G_va_li¡
+ 
+__¬g
+)
+
+396 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 2, 0)));
+
+397 

+	$d´štf
+ (
+__fd
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+398 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 2, 3)));
+
+402 
+__BEGIN_NAMESPACE_STD
+
+
+407 

+	$fsÿnf
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+408 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__wur
+;
+
+413 

+	$sÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__wur
+;
+
+415 

+	$ssÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+416 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__THROW
+;
+
+418 #ià
+defšed
+ 
+__USE_ISOC99
+ && !defšed 
+__USE_GNU
+ \
+
+419 && (!
+defšed
+ 
+__LDBL_COMPAT
+ || !defšed 
+__REDIRECT
+) \
+
+420 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+421 #ifdeà
+__REDIRECT
+
+
+425 

+	`__REDIRECT
+ (
+fsÿnf
+, (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+426 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...),
+
+427 
+__isoc99_fsÿnf
+è
+__wur
+;
+
+428 

+	`__REDIRECT
+ (
+sÿnf
+, (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...),
+
+429 
+__isoc99_sÿnf
+è
+__wur
+;
+
+430 

+	`__REDIRECT
+ (
+ssÿnf
+, (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+431 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...),
+
+432 
+__isoc99_ssÿnf
+è
+__THROW
+;
+
+434 

+	$__isoc99_fsÿnf
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+435 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__wur
+;
+
+436 

+	$__isoc99_sÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__wur
+;
+
+437 

+	$__isoc99_ssÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+438 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__THROW
+;
+
+439 

+	#fsÿnf
+ 
+__isoc99_fsÿnf
+
+
+	)
+
+440 

+	#sÿnf
+ 
+__isoc99_sÿnf
+
+
+	)
+
+441 

+	#ssÿnf
+ 
+__isoc99_ssÿnf
+
+
+	)
+
+445 
+__END_NAMESPACE_STD
+
+
+447 #ifdef 
+__USE_ISOC99
+
+
+448 
+__BEGIN_NAMESPACE_C99
+
+
+453 

+	$vfsÿnf
+ (
+FILE
+ *
+__»¡riù
+ 
+__s
+, 
+__cÚ¡
+ *__»¡riù 
+__fÜm©
+,
+
+454 
+_G_va_li¡
+ 
+__¬g
+)
+
+455 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__sÿnf__
+, 2, 0))è
+__wur
+;
+
+461 

+	$vsÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__¬g
+)
+
+462 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__sÿnf__
+, 1, 0))è
+__wur
+;
+
+465 

+	$vssÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+466 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__¬g
+)
+
+467 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__sÿnf__
+, 2, 0)));
+
+469 #ià!
+defšed
+ 
+__USE_GNU
+ \
+
+470 && (!
+defšed
+ 
+__LDBL_COMPAT
+ || !defšed 
+__REDIRECT
+) \
+
+471 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+472 #ifdeà
+__REDIRECT
+
+
+476 

+	`__REDIRECT
+ (
+vfsÿnf
+,
+
+477 (
+FILE
+ *
+__»¡riù
+ 
+__s
+,
+
+478 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__¬g
+),
+
+479 
+__isoc99_vfsÿnf
+)
+
+480 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__sÿnf__
+, 2, 0))è
+__wur
+;
+
+481 

+	`__REDIRECT
+ (
+vsÿnf
+, (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+482 
+_G_va_li¡
+ 
+__¬g
+), 
+__isoc99_vsÿnf
+)
+
+483 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__sÿnf__
+, 1, 0))è
+__wur
+;
+
+484 

+	`__REDIRECT
+ (
+vssÿnf
+,
+
+485 (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+486 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__¬g
+),
+
+487 
+__isoc99_vssÿnf
+)
+
+488 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__sÿnf__
+, 2, 0)));
+
+490 

+	$__isoc99_vfsÿnf
+ (
+FILE
+ *
+__»¡riù
+ 
+__s
+,
+
+491 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+492 
+_G_va_li¡
+ 
+__¬g
+è
+__wur
+;
+
+493 

+	$__isoc99_vsÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+494 
+_G_va_li¡
+ 
+__¬g
+è
+__wur
+;
+
+495 

+	$__isoc99_vssÿnf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+496 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+497 
+_G_va_li¡
+ 
+__¬g
+è
+__THROW
+;
+
+498 

+	#vfsÿnf
+ 
+__isoc99_vfsÿnf
+
+
+	)
+
+499 

+	#vsÿnf
+ 
+__isoc99_vsÿnf
+
+
+	)
+
+500 

+	#vssÿnf
+ 
+__isoc99_vssÿnf
+
+
+	)
+
+504 
+__END_NAMESPACE_C99
+
+
+508 
+__BEGIN_NAMESPACE_STD
+
+
+513 

+	`fg‘c
+ (
+FILE
+ *
+__¡»am
+);
+
+514 

+	`g‘c
+ (
+FILE
+ *
+__¡»am
+);
+
+520 

+	`g‘ch¬
+ ();
+
+521 
+__END_NAMESPACE_STD
+
+
+525 

+	#g‘c
+(
+_å
+è
+	`_IO_g‘c
+ (_å)
+
+	)
+
+527 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+532 

+	`g‘c_uÆocked
+ (
+FILE
+ *
+__¡»am
+);
+
+533 

+	`g‘ch¬_uÆocked
+ ();
+
+536 #ifdeà
+__USE_MISC
+
+
+543 

+	`fg‘c_uÆocked
+ (
+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_uÆocked
+ (
+__c
+, 
+FILE
+ *
+__¡»am
+);
+
+579 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+584 

+	`putc_uÆocked
+ (
+__c
+, 
+FILE
+ *
+__¡»am
+);
+
+585 

+	`putch¬_uÆocked
+ (
+__c
+);
+
+589 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_MISC
+ \
+
+590 || (
+defšed
+ 
+__USE_XOPEN
+ && !defšed 
+__USE_XOPEN2K
+)
+
+592 

+	`g‘w
+ (
+FILE
+ *
+__¡»am
+);
+
+595 

+	`putw
+ (
+__w
+, 
+FILE
+ *
+__¡»am
+);
+
+599 
+__BEGIN_NAMESPACE_STD
+
+
+604 
*
+	$fg‘s
+ (*
+__»¡riù
+ 
+__s
+, 
+__n
+, 
+FILE
+ *__»¡riù 
+__¡»am
+)
+
+605 
+__wur
+;
+
+612 
*
+	$g‘s
+ (*
+__s
+è
+__wur
+;
+
+613 
+__END_NAMESPACE_STD
+
+
+615 #ifdeà
+__USE_GNU
+
+
+622 
*
+	$fg‘s_uÆocked
+ (*
+__»¡riù
+ 
+__s
+, 
+__n
+,
+
+623 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+627 #ifdef 
+__USE_XOPEN2K8
+
+
+638 

+_IO_ssize_t
+ 
+	$__g‘d–im
+ (**
+__»¡riù
+ 
+__lš•Œ
+,
+
+639 
+size_t
+ *
+__»¡riù
+ 
+__n
+, 
+__d–im™”
+,
+
+640 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+641 

+_IO_ssize_t
+ 
+	$g‘d–im
+ (**
+__»¡riù
+ 
+__lš•Œ
+,
+
+642 
+size_t
+ *
+__»¡riù
+ 
+__n
+, 
+__d–im™”
+,
+
+643 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+651 

+_IO_ssize_t
+ 
+	$g‘lše
+ (**
+__»¡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 

+	`ung‘c
+ (
+__c
+, 
+FILE
+ *
+__¡»am
+);
+
+682 

+size_t
+ 
+	$ä—d
+ (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__size
+,
+
+683 
+size_t
+ 
+__n
+, 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+688 

+size_t
+ 
+	`fwr™e
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__±r
+, size_ˆ
+__size
+,
+
+689 
+size_t
+ 
+__n
+, 
+FILE
+ *
+__»¡riù
+ 
+__s
+);
+
+690 
+__END_NAMESPACE_STD
+
+
+692 #ifdeà
+__USE_GNU
+
+
+699 

+	`åuts_uÆocked
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+,
+
+700 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+);
+
+703 #ifdeà
+__USE_MISC
+
+
+710 

+size_t
+ 
+	$ä—d_uÆocked
+ (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__size
+,
+
+711 
+size_t
+ 
+__n
+, 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+712 

+size_t
+ 
+	`fwr™e_uÆocked
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__±r
+, size_ˆ
+__size
+,
+
+713 
+size_t
+ 
+__n
+, 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+);
+
+717 
+__BEGIN_NAMESPACE_STD
+
+
+722 

+	`f£ek
+ (
+FILE
+ *
+__¡»am
+, 
+__off
+, 
+__wh’û
+);
+
+727 

+	$á–l
+ (
+FILE
+ *
+__¡»am
+è
+__wur
+;
+
+732 

+	`»wšd
+ (
+FILE
+ *
+__¡»am
+);
+
+733 
+__END_NAMESPACE_STD
+
+
+740 #ià
+defšed
+ 
+__USE_LARGEFILE
+ || defšed 
+__USE_XOPEN2K
+
+
+741 #iâdeà
+__USE_FILE_OFFSET64
+
+
+746 

+	`f£eko
+ (
+FILE
+ *
+__¡»am
+, 
+__off_t
+ 
+__off
+, 
+__wh’û
+);
+
+751 

+__off_t
+ 
+	$á–lo
+ (
+FILE
+ *
+__¡»am
+è
+__wur
+;
+
+753 #ifdeà
+__REDIRECT
+
+
+754 

+	`__REDIRECT
+ (
+f£eko
+,
+
+755 (
+FILE
+ *
+__¡»am
+, 
+__off64_t
+ 
+__off
+, 
+__wh’û
+),
+
+756 
+f£eko64
+);
+
+757 

+__off64_t
+ 
+	`__REDIRECT
+ (
+á–lo
+, (
+FILE
+ *
+__¡»am
+), 
+á–lo64
+);
+
+759 

+	#f£eko
+ 
+f£eko64
+
+
+	)
+
+760 

+	#á–lo
+ 
+á–lo64
+
+
+	)
+
+765 
+__BEGIN_NAMESPACE_STD
+
+
+766 #iâdeà
+__USE_FILE_OFFSET64
+
+
+771 

+	`fg‘pos
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+åos_t
+ *__»¡riù 
+__pos
+);
+
+776 

+	`f£�os
+ (
+FILE
+ *
+__¡»am
+, 
+__cÚ¡
+ 
+åos_t
+ *
+__pos
+);
+
+778 #ifdeà
+__REDIRECT
+
+
+779 

+	`__REDIRECT
+ (
+fg‘pos
+, (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+780 
+åos_t
+ *
+__»¡riù
+ 
+__pos
+), 
+fg‘pos64
+);
+
+781 

+	`__REDIRECT
+ (
+f£�os
+,
+
+782 (
+FILE
+ *
+__¡»am
+, 
+__cÚ¡
+ 
+åos_t
+ *
+__pos
+), 
+f£�os64
+);
+
+784 

+	#fg‘pos
+ 
+fg‘pos64
+
+
+	)
+
+785 

+	#f£�os
+ 
+f£�os64
+
+
+	)
+
+788 
+__END_NAMESPACE_STD
+
+
+790 #ifdeà
+__USE_LARGEFILE64
+
+
+791 

+	`f£eko64
+ (
+FILE
+ *
+__¡»am
+, 
+__off64_t
+ 
+__off
+, 
+__wh’û
+);
+
+792 

+__off64_t
+ 
+	$á–lo64
+ (
+FILE
+ *
+__¡»am
+è
+__wur
+;
+
+793 

+	`fg‘pos64
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+åos64_t
+ *__»¡riù 
+__pos
+);
+
+794 

+	`f£�os64
+ (
+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 

+	$þ—»¼_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+809 

+	$ãof_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+ 
+__wur
+;
+
+810 

+	$ã¼Ü_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+ 
+__wur
+;
+
+814 
+__BEGIN_NAMESPACE_STD
+
+
+819 

+	`³¼Ü
+ (
+__cÚ¡
+ *
+__s
+);
+
+820 
+__END_NAMESPACE_STD
+
+
+826 
+	~<b™s/sys_”¾i¡.h
+>
+
+829 #ifdef 
+__USE_POSIX
+
+
+831 

+	$fž’o
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+ 
+__wur
+;
+
+834 #ifdeà
+__USE_MISC
+
+
+836 

+	$fž’o_uÆocked
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+ 
+__wur
+;
+
+840 #ià(
+defšed
+ 
+__USE_POSIX2
+ || defšed 
+__USE_SVID
+ || defšed 
+__USE_BSD
+ || \
+
+841 
+defšed
+ 
+__USE_MISC
+)
+
+846 

+FILE
+ *
+	$pÝ’
+ (
+__cÚ¡
+ *
+__commªd
+, __cÚ¡ *
+__modes
+è
+__wur
+;
+
+852 

+	`pþo£
+ (
+FILE
+ *
+__¡»am
+);
+
+856 #ifdef 
+__USE_POSIX
+
+
+858 
*
+	$ù”mid
+ (*
+__s
+è
+__THROW
+;
+
+862 #ifdeà
+__USE_XOPEN
+
+
+864 
*
+	`cu£rid
+ (*
+__s
+);
+
+868 #ifdef 
+__USE_GNU
+
+
+869 
+ob¡ack
+;
+
+872 

+	$ob¡ack_´štf
+ (
+ob¡ack
+ *
+__»¡riù
+ 
+__ob¡ack
+,
+
+873 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+874 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 2, 3)));
+
+875 

+	$ob¡ack_v´štf
+ (
+ob¡ack
+ *
+__»¡riù
+ 
+__ob¡ack
+,
+
+876 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+877 
+_G_va_li¡
+ 
+__¬gs
+)
+
+878 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 2, 0)));
+
+882 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+886 

+	$æockfže
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+890 

+	$árylockfže
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+ 
+__wur
+;
+
+893 

+	$fuÆockfže
+ (
+FILE
+ *
+__¡»am
+è
+__THROW
+;
+
+896 #ià
+defšed
+ 
+__USE_XOPEN
+ && !defšed 
+__USE_XOPEN2K
+ && !defšed 
+__USE_GNU
+
+
+900 

+	#__Ãed_g‘Ýt
+
+
+	)
+
+901 
+	~<g‘Ýt.h
+>
+
+906 #ifdeà
+__USE_EXTERN_INLINES
+
+
+907 
+	~<b™s/¡dio.h
+>
+
+909 #ià
+__USE_FORTIFY_LEVEL
+ > 0 && 
+defšed
+ 
+__ex‹º_®ways_šlše
+
+
+910 
+	~<b™s/¡dio2.h
+>
+
+912 #ifdeà
+__LDBL_COMPAT
+
+
+913 
+	~<b™s/¡dio-ldbl.h
+>
+
+916 
+__END_DECLS
+
+
+	@/usr/include/bits/stdio-ldbl.h
+
+20 #iâdeà
+_STDIO_H
+
+
+24 
+__BEGIN_NAMESPACE_STD
+
+
+25 
+	$__LDBL_REDIR_DECL
+ (
+årštf
+)
+
+26 
+	$__LDBL_REDIR_DECL
+ (
+´štf
+)
+
+27 
+	$__LDBL_REDIR_DECL
+ (
+¥rštf
+)
+
+28 
+	$__LDBL_REDIR_DECL
+ (
+vårštf
+)
+
+29 
+	$__LDBL_REDIR_DECL
+ (
+v´štf
+)
+
+30 
+	$__LDBL_REDIR_DECL
+ (
+v¥rštf
+)
+
+31 #ià
+defšed
+ 
+__USE_ISOC99
+ && !defšed 
+__USE_GNU
+ \
+
+32 && !
+defšed
+ 
+__REDIRECT
+ \
+
+33 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+34 
+	$__LDBL_REDIR1_DECL
+ (
+fsÿnf
+, 
+__Ædbl___isoc99_fsÿnf
+)
+
+35 
+	$__LDBL_REDIR1_DECL
+ (
+sÿnf
+, 
+__Ædbl___isoc99_sÿnf
+)
+
+36 
+	$__LDBL_REDIR1_DECL
+ (
+ssÿnf
+, 
+__Ædbl___isoc99_ssÿnf
+)
+
+38 
+	$__LDBL_REDIR_DECL
+ (
+fsÿnf
+)
+
+39 
+	$__LDBL_REDIR_DECL
+ (
+sÿnf
+)
+
+40 
+	$__LDBL_REDIR_DECL
+ (
+ssÿnf
+)
+
+42 
+__END_NAMESPACE_STD
+
+
+44 #ià
+defšed
+ 
+__USE_BSD
+ || defšed 
+__USE_ISOC99
+ || defšed 
+__USE_UNIX98
+
+
+45 
+__BEGIN_NAMESPACE_C99
+
+
+46 
+	$__LDBL_REDIR_DECL
+ (
+¢´štf
+)
+
+47 
+	$__LDBL_REDIR_DECL
+ (
+v¢´štf
+)
+
+48 
+__END_NAMESPACE_C99
+
+
+51 #ifdef 
+__USE_ISOC99
+
+
+52 
+__BEGIN_NAMESPACE_C99
+
+
+53 #ià!
+defšed
+ 
+__USE_GNU
+ && !defšed 
+__REDIRECT
+ \
+
+54 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+55 
+	$__LDBL_REDIR1_DECL
+ (
+vfsÿnf
+, 
+__Ædbl___isoc99_vfsÿnf
+)
+
+56 
+	$__LDBL_REDIR1_DECL
+ (
+vsÿnf
+, 
+__Ædbl___isoc99_vsÿnf
+)
+
+57 
+	$__LDBL_REDIR1_DECL
+ (
+vssÿnf
+, 
+__Ædbl___isoc99_vssÿnf
+)
+
+59 
+	$__LDBL_REDIR_DECL
+ (
+vfsÿnf
+)
+
+60 
+	$__LDBL_REDIR_DECL
+ (
+vssÿnf
+)
+
+61 
+	$__LDBL_REDIR_DECL
+ (
+vsÿnf
+)
+
+63 
+__END_NAMESPACE_C99
+
+
+66 #ifdeà
+__USE_GNU
+
+
+67 
+	$__LDBL_REDIR_DECL
+ (
+vd´štf
+)
+
+68 
+	$__LDBL_REDIR_DECL
+ (
+d´štf
+)
+
+69 
+	$__LDBL_REDIR_DECL
+ (
+va¥rštf
+)
+
+70 
+	$__LDBL_REDIR_DECL
+ (
+__a¥rštf
+)
+
+71 
+	$__LDBL_REDIR_DECL
+ (
+a¥rštf
+)
+
+72 
+	$__LDBL_REDIR_DECL
+ (
+ob¡ack_´štf
+)
+
+73 
+	$__LDBL_REDIR_DECL
+ (
+ob¡ack_v´štf
+)
+
+76 #ià
+__USE_FORTIFY_LEVEL
+ > 0 && 
+defšed
+ 
+__ex‹º_®ways_šlše
+
+
+77 
+	$__LDBL_REDIR_DECL
+ (
+__¥rštf_chk
+)
+
+78 
+	$__LDBL_REDIR_DECL
+ (
+__v¥rštf_chk
+)
+
+79 #ià
+defšed
+ 
+__USE_BSD
+ || defšed 
+__USE_ISOC99
+ || defšed 
+__USE_UNIX98
+
+
+80 
+	$__LDBL_REDIR_DECL
+ (
+__¢´štf_chk
+)
+
+81 
+	$__LDBL_REDIR_DECL
+ (
+__v¢´štf_chk
+)
+
+83 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+84 
+	$__LDBL_REDIR_DECL
+ (
+__årštf_chk
+)
+
+85 
+	$__LDBL_REDIR_DECL
+ (
+__´štf_chk
+)
+
+86 
+	$__LDBL_REDIR_DECL
+ (
+__vårštf_chk
+)
+
+87 
+	$__LDBL_REDIR_DECL
+ (
+__v´štf_chk
+)
+
+88 #ifdeà
+__USE_GNU
+
+
+89 
+	$__LDBL_REDIR_DECL
+ (
+__a¥rštf_chk
+)
+
+90 
+	$__LDBL_REDIR_DECL
+ (
+__va¥rštf_chk
+)
+
+91 
+	$__LDBL_REDIR_DECL
+ (
+__d´štf_chk
+)
+
+92 
+	$__LDBL_REDIR_DECL
+ (
+__vd´štf_chk
+)
+
+93 
+	$__LDBL_REDIR_DECL
+ (
+__ob¡ack_´štf_chk
+)
+
+94 
+	$__LDBL_REDIR_DECL
+ (
+__ob¡ack_v´štf_chk
+)
+
+	@/usr/include/bits/stdio.h
+
+20 #iâdeà
+_STDIO_H
+
+
+24 #iâdeà
+__ex‹º_šlše
+
+
+25 

+	#__STDIO_INLINE
+ 
+šlše
+
+
+	)
+
+27 

+	#__STDIO_INLINE
+ 
+__ex‹º_šlše
+
+
+	)
+
+31 #ifdeà
+__USE_EXTERN_INLINES
+
+
+34 #ià!(
+__USE_FORTIFY_LEVEL
+ > 0 && 
+defšed
+ 
+__ex‹º_®ways_šlše
+)
+
+36 
+__STDIO_INLINE
+ 
+
+37 
+	$v´štf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__¬g
+)
+
+39  
+	`vårštf
+ (
+¡dout
+, 
+__fmt
+, 
+__¬g
+);
+
+40 
+	}
+}
+
+44 
+__STDIO_INLINE
+ 
+
+45 
+	$g‘ch¬
+ ()
+
+47  
+	`_IO_g‘c
+ (
+¡dš
+);
+
+48 
+	}
+}
+
+51 #ifdeà
+__USE_MISC
+
+
+53 
+__STDIO_INLINE
+ 
+
+54 
+	$fg‘c_uÆocked
+ (
+FILE
+ *
+__å
+)
+
+56  
+	`_IO_g‘c_uÆocked
+ (
+__å
+);
+
+57 
+	}
+}
+
+61 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+63 
+__STDIO_INLINE
+ 
+
+64 
+	$g‘c_uÆocked
+ (
+FILE
+ *
+__å
+)
+
+66  
+	`_IO_g‘c_uÆocked
+ (
+__å
+);
+
+67 
+	}
+}
+
+70 
+__STDIO_INLINE
+ 
+
+71 
+	$g‘ch¬_uÆocked
+ ()
+
+73  
+	`_IO_g‘c_uÆocked
+ (
+¡dš
+);
+
+74 
+	}
+}
+
+79 
+__STDIO_INLINE
+ 
+
+80 
+	$putch¬
+ (
+__c
+)
+
+82  
+	`_IO_putc
+ (
+__c
+, 
+¡dout
+);
+
+83 
+	}
+}
+
+86 #ifdeà
+__USE_MISC
+
+
+88 
+__STDIO_INLINE
+ 
+
+89 
+	$åutc_uÆocked
+ (
+__c
+, 
+FILE
+ *
+__¡»am
+)
+
+91  
+	`_IO_putc_uÆocked
+ (
+__c
+, 
+__¡»am
+);
+
+92 
+	}
+}
+
+96 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+98 
+__STDIO_INLINE
+ 
+
+99 
+	$putc_uÆocked
+ (
+__c
+, 
+FILE
+ *
+__¡»am
+)
+
+101  
+	`_IO_putc_uÆocked
+ (
+__c
+, 
+__¡»am
+);
+
+102 
+	}
+}
+
+105 
+__STDIO_INLINE
+ 
+
+106 
+	$putch¬_uÆocked
+ (
+__c
+)
+
+108  
+	`_IO_putc_uÆocked
+ (
+__c
+, 
+¡dout
+);
+
+109 
+	}
+}
+
+113 #ifdef 
+__USE_GNU
+
+
+115 
+__STDIO_INLINE
+ 
+_IO_ssize_t
+
+
+116 
+	$g‘lše
+ (**
+__lš•Œ
+, 
+size_t
+ *
+__n
+, 
+FILE
+ *
+__¡»am
+)
+
+118  
+	`__g‘d–im
+ (
+__lš•Œ
+, 
+__n
+, '\n', 
+__¡»am
+);
+
+119 
+	}
+}
+
+123 #ifdeà
+__USE_MISC
+
+
+125 
+__STDIO_INLINE
+ 
+
+126 
+__NTH
+ (
+	$ãof_uÆocked
+ (
+FILE
+ *
+__¡»am
+))
+
+128  
+	`_IO_ãof_uÆocked
+ (
+__¡»am
+);
+
+129 
+	}
+}
+
+132 
+__STDIO_INLINE
+ 
+
+133 
+__NTH
+ (
+	$ã¼Ü_uÆocked
+ (
+FILE
+ *
+__¡»am
+))
+
+135  
+	`_IO_ã¼Ü_uÆocked
+ (
+__¡»am
+);
+
+136 
+	}
+}
+
+142 #ià
+defšed
+ 
+__USE_MISC
+ && defšed 
+__GNUC__
+ && defšed 
+__OPTIMIZE__
+ \
+
+143 && !
+defšed
+ 
+	g__ýlu¥lus
+
+
+145 

+	#ä—d_uÆocked
+(
+±r
+, 
+size
+, 
+n
+, 
+¡»am
+) \
+
+146 (
+	`__ex‹nsiÚ__
+ ((
+	`__bužtš_cÚ¡ªt_p
+ (
+size
+è&& __bužtš_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_g‘c_uÆocked
+ (
+__¡»am
+); \
+
+156 ià(
+__c
+ =ð
+EOF
+) \
+
+158 *
+__±r
+++ = 
+__c
+; \
+
+160 ((
+size_t
+è(
+size
+è* (size_tè(
+n
+è- 
+__út
+) \
+
+161 / (
+size_t
+è(
+size
+); }) \
+
+162 : (((
+	`__bužtš_cÚ¡ªt_p
+ (
+size
+è&& (
+size_t
+) (size) == 0) \
+
+163 || (
+	`__bužtš_cÚ¡ªt_p
+ (
+n
+è&& (
+size_t
+) (n) == 0)) \
+
+165 ? ((è(
+±r
+), (è(
+¡»am
+), (è(
+size
+), \
+
+166 (è(
+n
+), (
+size_t
+) 0) \
+
+167 : 
+	`ä—d_uÆocked
+ (
+±r
+, 
+size
+, 
+n
+, 
+¡»am
+))))
+
+	)
+
+169 

+	#fwr™e_uÆocked
+(
+±r
+, 
+size
+, 
+n
+, 
+¡»am
+) \
+
+170 (
+	`__ex‹nsiÚ__
+ ((
+	`__bužtš_cÚ¡ªt_p
+ (
+size
+è&& __bužtš_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_uÆocked
+ (*
+__±r
+++, 
+__¡»am
+è=ð
+EOF
+) \
+
+180 ((
+size_t
+è(
+size
+è* (size_tè(
+n
+è- 
+__út
+) \
+
+181 / (
+size_t
+è(
+size
+); }) \
+
+182 : (((
+	`__bužtš_cÚ¡ªt_p
+ (
+size
+è&& (
+size_t
+) (size) == 0) \
+
+183 || (
+	`__bužtš_cÚ¡ªt_p
+ (
+n
+è&& (
+size_t
+) (n) == 0)) \
+
+185 ? ((è(
+±r
+), (è(
+¡»am
+), (è(
+size
+), \
+
+186 (è(
+n
+), (
+size_t
+) 0) \
+
+187 : 
+	`fwr™e_uÆocked
+ (
+±r
+, 
+size
+, 
+n
+, 
+¡»am
+))))
+
+	)
+
+191 #undeà
+__STDIO_INLINE
+
+
+	@/usr/include/bits/stdio2.h
+
+20 #iâdeà
+_STDIO_H
+
+
+24 

+	$__¥rštf_chk
+ (*
+__»¡riù
+ 
+__s
+, 
+__æag
+, 
+size_t
+ 
+__¦’
+,
+
+25 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...è
+__THROW
+;
+
+26 

+	$__v¥rštf_chk
+ (*
+__»¡riù
+ 
+__s
+, 
+__æag
+, 
+size_t
+ 
+__¦’
+,
+
+27 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+28 
+_G_va_li¡
+ 
+__­
+è
+__THROW
+;
+
+30 #ifdeà
+__va_¬g_·ck
+
+
+31 
+__ex‹º_®ways_šlše
+ 
+
+32 
+	`__NTH
+ (
+	$¥rštf
+ (*
+__»¡riù
+ 
+__s
+, 
+__cÚ¡
+ *__»¡riù 
+__fmt
+, ...))
+
+34  
+	`__bužtš___¥rštf_chk
+ (
+__s
+, 
+__USE_FORTIFY_LEVEL
+ - 1,
+
+35 
+	`__bos
+ (
+__s
+), 
+__fmt
+, 
+	`__va_¬g_·ck
+ ());
+
+36 
+	}
+}
+
+37 #–ià!
+defšed
+ 
+__ýlu¥lus
+
+
+38 

+	#¥rštf
+(
+¡r
+, ...) \
+
+39 
+	`__bužtš___¥rštf_chk
+ (
+¡r
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+	`__bos
+ (str), \
+
+40 
+__VA_ARGS__
+)
+
+	)
+
+43 
+__ex‹º_®ways_šlše
+ 
+
+44 
+__NTH
+ (
+	$v¥rštf
+ (*
+__»¡riù
+ 
+__s
+, 
+__cÚ¡
+ *__»¡riù 
+__fmt
+,
+
+45 
+_G_va_li¡
+ 
+__­
+))
+
+47  
+	`__bužtš___v¥rštf_chk
+ (
+__s
+, 
+__USE_FORTIFY_LEVEL
+ - 1,
+
+48 
+	`__bos
+ (
+__s
+), 
+__fmt
+, 
+__­
+);
+
+49 
+	}
+}
+
+51 #ià
+defšed
+ 
+__USE_BSD
+ || defšed 
+__USE_ISOC99
+ || defšed 
+__USE_UNIX98
+
+
+53 

+	$__¢´štf_chk
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+, 
+__æag
+,
+
+54 
+size_t
+ 
+__¦’
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+55 ...è
+__THROW
+;
+
+56 

+	$__v¢´štf_chk
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+, 
+__æag
+,
+
+57 
+size_t
+ 
+__¦’
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+58 
+_G_va_li¡
+ 
+__­
+è
+__THROW
+;
+
+60 #ifdeà
+__va_¬g_·ck
+
+
+61 
+__ex‹º_®ways_šlše
+ 
+
+62 
+	`__NTH
+ (
+	$¢´štf
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+63 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...))
+
+65  
+	`__bužtš___¢´štf_chk
+ (
+__s
+, 
+__n
+, 
+__USE_FORTIFY_LEVEL
+ - 1,
+
+66 
+	`__bos
+ (
+__s
+), 
+__fmt
+, 
+	`__va_¬g_·ck
+ ());
+
+67 
+	}
+}
+
+68 #–ià!
+defšed
+ 
+__ýlu¥lus
+
+
+69 

+	#¢´štf
+(
+¡r
+, 
+Ën
+, ...) \
+
+70 
+	`__bužtš___¢´štf_chk
+ (
+¡r
+, 
+Ën
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+	`__bos
+ (str), \
+
+71 
+__VA_ARGS__
+)
+
+	)
+
+74 
+__ex‹º_®ways_šlše
+ 
+
+75 
+__NTH
+ (
+	$v¢´štf
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+76 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__­
+))
+
+78  
+	`__bužtš___v¢´štf_chk
+ (
+__s
+, 
+__n
+, 
+__USE_FORTIFY_LEVEL
+ - 1,
+
+79 
+	`__bos
+ (
+__s
+), 
+__fmt
+, 
+__­
+);
+
+80 
+	}
+}
+
+84 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+86 

+__årštf_chk
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+__æag
+,
+
+87 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+88 

+__´štf_chk
+ (
+__æag
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+89 

+__vårštf_chk
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+__æag
+,
+
+90 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+, 
+_G_va_li¡
+ 
+__­
+);
+
+91 

+__v´štf_chk
+ (
+__æag
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+92 
+_G_va_li¡
+ 
+__­
+);
+
+94 #ifdeà
+__va_¬g_·ck
+
+
+95 
+__ex‹º_®ways_šlše
+ 
+
+96 
+	$årštf
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+__cÚ¡
+ *__»¡riù 
+__fmt
+, ...)
+
+98  
+	`__årštf_chk
+ (
+__¡»am
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+99 
+	`__va_¬g_·ck
+ ());
+
+100 
+	}
+}
+
+102 
+__ex‹º_®ways_šlše
+ 
+
+103 
+	$´štf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+105  
+	`__´štf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+	`__va_¬g_·ck
+ ());
+
+106 
+	}
+}
+
+107 #–ià!
+defšed
+ 
+__ýlu¥lus
+
+
+108 

+	#´štf
+(...) \
+
+109 
+	`__´štf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+110 

+	#årštf
+(
+¡»am
+, ...) \
+
+111 
+	`__årštf_chk
+ (
+¡»am
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+114 
+__ex‹º_®ways_šlše
+ 
+
+115 
+	$v´štf
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__­
+)
+
+117 #ifdeà
+__USE_EXTERN_INLINES
+
+
+118  
+	`__vårštf_chk
+ (
+¡dout
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+120  
+	`__v´štf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+122 
+	}
+}
+
+124 
+__ex‹º_®ways_šlše
+ 
+
+125 
+	$vårštf
+ (
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+126 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__­
+)
+
+128  
+	`__vårštf_chk
+ (
+__¡»am
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+129 
+	}
+}
+
+131 #ifdeà
+__USE_GNU
+
+
+133 

+	$__a¥rštf_chk
+ (**
+__»¡riù
+ 
+__±r
+, 
+__æag
+,
+
+134 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+135 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__´štf__
+, 3, 4))è
+__wur
+;
+
+136 

+	$__va¥rštf_chk
+ (**
+__»¡riù
+ 
+__±r
+, 
+__æag
+,
+
+137 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__¬g
+)
+
+138 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	$__fÜm©__
+ (
+__´štf__
+, 3, 0))è
+__wur
+;
+
+139 

+	$__d´štf_chk
+ (
+__fd
+, 
+__æag
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+,
+
+140 ...è
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 3, 4)));
+
+141 

+	$__vd´štf_chk
+ (
+__fd
+, 
+__æag
+,
+
+142 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__¬g
+)
+
+143 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 3, 0)));
+
+144 

+	$__ob¡ack_´štf_chk
+ (
+ob¡ack
+ *
+__»¡riù
+ 
+__ob¡ack
+,
+
+145 
+__æag
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+147 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 3, 4)));
+
+148 

+	$__ob¡ack_v´štf_chk
+ (
+ob¡ack
+ *
+__»¡riù
+ 
+__ob¡ack
+,
+
+149 
+__æag
+,
+
+150 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+151 
+_G_va_li¡
+ 
+__¬gs
+)
+
+152 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__´štf__
+, 3, 0)));
+
+154 #ifdeà
+__va_¬g_·ck
+
+
+155 
+__ex‹º_®ways_šlše
+ 
+
+156 
+	`__NTH
+ (
+	$a¥rštf
+ (**
+__»¡riù
+ 
+__±r
+, 
+__cÚ¡
+ *__»¡riù 
+__fmt
+, ...))
+
+158  
+	`__a¥rštf_chk
+ (
+__±r
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+159 
+	`__va_¬g_·ck
+ ());
+
+160 
+	}
+}
+
+162 
+__ex‹º_®ways_šlše
+ 
+
+163 
+__NTH
+ (
+	$__a¥rštf
+ (**
+__»¡riù
+ 
+__±r
+, 
+__cÚ¡
+ *__»¡riù 
+__fmt
+,
+
+166  
+	`__a¥rštf_chk
+ (
+__±r
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+167 
+	`__va_¬g_·ck
+ ());
+
+168 
+	}
+}
+
+170 
+__ex‹º_®ways_šlše
+ 
+
+171 
+	$d´štf
+ (
+__fd
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+173  
+	`__d´štf_chk
+ (
+__fd
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+174 
+	`__va_¬g_·ck
+ ());
+
+175 
+	}
+}
+
+177 
+__ex‹º_®ways_šlše
+ 
+
+178 
+__NTH
+ (
+	$ob¡ack_´štf
+ (
+ob¡ack
+ *
+__»¡riù
+ 
+__ob¡ack
+,
+
+179 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, ...))
+
+181  
+	`__ob¡ack_´štf_chk
+ (
+__ob¡ack
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+182 
+	`__va_¬g_·ck
+ ());
+
+183 
+	}
+}
+
+184 #–ià!
+defšed
+ 
+__ýlu¥lus
+
+
+185 

+	#a¥rštf
+(
+±r
+, ...) \
+
+186 
+	`__a¥rštf_chk
+ (
+±r
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+187 

+	#__a¥rštf
+(
+±r
+, ...) \
+
+188 
+	`__a¥rštf_chk
+ (
+±r
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+189 

+	#d´štf
+(
+fd
+, ...) \
+
+190 
+	`__d´štf_chk
+ (
+fd
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+191 

+	#ob¡ack_´štf
+(
+ob¡ack
+, ...) \
+
+192 
+	`__ob¡ack_´štf_chk
+ (
+ob¡ack
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+195 
+__ex‹º_®ways_šlše
+ 
+
+196 
+__NTH
+ (
+	$va¥rštf
+ (**
+__»¡riù
+ 
+__±r
+, 
+__cÚ¡
+ *__»¡riù 
+__fmt
+,
+
+197 
+_G_va_li¡
+ 
+__­
+))
+
+199  
+	`__va¥rštf_chk
+ (
+__±r
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+200 
+	}
+}
+
+202 
+__ex‹º_®ways_šlše
+ 
+
+203 
+	$vd´štf
+ (
+__fd
+, 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__­
+)
+
+205  
+	`__vd´štf_chk
+ (
+__fd
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+206 
+	}
+}
+
+208 
+__ex‹º_®ways_šlše
+ 
+
+209 
+__NTH
+ (
+	$ob¡ack_v´štf
+ (
+ob¡ack
+ *
+__»¡riù
+ 
+__ob¡ack
+,
+
+210 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fmt
+, 
+_G_va_li¡
+ 
+__­
+))
+
+212  
+	`__ob¡ack_v´štf_chk
+ (
+__ob¡ack
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+213 
+__­
+);
+
+214 
+	}
+}
+
+220 
*
+	$__g‘s_chk
+ (*
+__¡r
+, 
+size_t
+è
+__wur
+;
+
+221 
*
+	`__REDIRECT
+ (
+__g‘s_w¬n
+, (*
+__¡r
+), 
+g‘s
+)
+
+222 
+__wur
+ 
+	`__w¬Ç‰r
+ ("please use fgets or getline instead, gets can't "
+
+225 
+__ex‹º_®ways_šlše
+ 
+__wur
+ *
+
+226 
+	$g‘s
+ (*
+__¡r
+)
+
+228 ià(
+	`__bos
+ (
+__¡r
+è!ð(
+size_t
+) -1)
+
+229  
+	`__g‘s_chk
+ (
+__¡r
+, 
+	`__bos
+ (__str));
+
+230  
+	`__g‘s_w¬n
+ (
+__¡r
+);
+
+231 
+	}
+}
+
+233 
*
+	$__fg‘s_chk
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+, 
+__n
+,
+
+234 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+235 
*
+	`__REDIRECT
+ (
+__fg‘s_®Ÿs
+,
+
+236 (*
+__»¡riù
+ 
+__s
+, 
+__n
+,
+
+237 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+fg‘s
+è
+__wur
+;
+
+238 
*
+	`__REDIRECT
+ (
+__fg‘s_chk_w¬n
+,
+
+239 (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+, 
+__n
+,
+
+240 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+__fg‘s_chk
+)
+
+241 
+__wur
+ 
+	`__w¬Ç‰r
+ ("fgets called with bigger size�han†ength "
+
+244 
+__ex‹º_®ways_šlše
+ 
+__wur
+ *
+
+245 
+	$fg‘s
+ (*
+__»¡riù
+ 
+__s
+, 
+__n
+, 
+FILE
+ *__»¡riù 
+__¡»am
+)
+
+247 ià(
+	`__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+249 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+250  
+	`__fg‘s_chk
+ (
+__s
+, 
+	`__bos
+ (__s), 
+__n
+, 
+__¡»am
+);
+
+252 ià((
+size_t
+è
+__n
+ > 
+	`__bos
+ (
+__s
+))
+
+253  
+	`__fg‘s_chk_w¬n
+ (
+__s
+, 
+	`__bos
+ (__s), 
+__n
+, 
+__¡»am
+);
+
+255  
+	`__fg‘s_®Ÿ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_w¬n
+,
+
+266 (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__±¾’
+,
+
+267 
+size_t
+ 
+__size
+, size_ˆ
+__n
+,
+
+268 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+),
+
+269 
+__ä—d_chk
+)
+
+270 
+__wur
+ 
+	`__w¬Ç‰r
+ ("fread called with bigger size *‚memb�han†ength "
+
+273 
+__ex‹º_®ways_šlše
+ 
+__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à(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__size
+)
+
+280 || !
+	`__bužtš_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_w¬n
+ (
+__±r
+, 
+	`__bos0
+ (__±r), 
+__size
+, 
+__n
+, 
+__¡»am
+);
+
+287  
+	`__ä—d_®Ÿs
+ (
+__±r
+, 
+__size
+, 
+__n
+, 
+__¡»am
+);
+
+288 
+	}
+}
+
+290 #ifdeà
+__USE_GNU
+
+
+291 
*
+	$__fg‘s_uÆocked_chk
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+,
+
+292 
+__n
+, 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+293 
*
+	`__REDIRECT
+ (
+__fg‘s_uÆocked_®Ÿs
+,
+
+294 (*
+__»¡riù
+ 
+__s
+, 
+__n
+,
+
+295 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+fg‘s_uÆocked
+è
+__wur
+;
+
+296 
*
+	`__REDIRECT
+ (
+__fg‘s_uÆocked_chk_w¬n
+,
+
+297 (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+, 
+__n
+,
+
+298 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+__fg‘s_uÆocked_chk
+)
+
+299 
+__wur
+ 
+	`__w¬Ç‰r
+ ("fgets_unlocked called with bigger size�han†ength "
+
+302 
+__ex‹º_®ways_šlše
+ 
+__wur
+ *
+
+303 
+	$fg‘s_uÆocked
+ (*
+__»¡riù
+ 
+__s
+, 
+__n
+, 
+FILE
+ *__»¡riù 
+__¡»am
+)
+
+305 ià(
+	`__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+307 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+308  
+	`__fg‘s_uÆocked_chk
+ (
+__s
+, 
+	`__bos
+ (__s), 
+__n
+, 
+__¡»am
+);
+
+310 ià((
+size_t
+è
+__n
+ > 
+	`__bos
+ (
+__s
+))
+
+311  
+	`__fg‘s_uÆocked_chk_w¬n
+ (
+__s
+, 
+	`__bos
+ (__s), 
+__n
+, 
+__¡»am
+);
+
+313  
+	`__fg‘s_uÆocked_®Ÿs
+ (
+__s
+, 
+__n
+, 
+__¡»am
+);
+
+314 
+	}
+}
+
+317 #ifdeà
+__USE_MISC
+
+
+318 #undeà
+ä—d_uÆocked
+
+
+319 

+size_t
+ 
+	$__ä—d_uÆocked_chk
+ (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__±¾’
+,
+
+320 
+size_t
+ 
+__size
+, size_ˆ
+__n
+,
+
+321 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+322 

+size_t
+ 
+	`__REDIRECT
+ (
+__ä—d_uÆocked_®Ÿs
+,
+
+323 (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__size
+,
+
+324 
+size_t
+ 
+__n
+, 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+),
+
+325 
+ä—d_uÆocked
+è
+__wur
+;
+
+326 

+size_t
+ 
+	`__REDIRECT
+ (
+__ä—d_uÆocked_chk_w¬n
+,
+
+327 (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__±¾’
+,
+
+328 
+size_t
+ 
+__size
+, size_ˆ
+__n
+,
+
+329 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+),
+
+330 
+__ä—d_uÆocked_chk
+)
+
+331 
+__wur
+ 
+	`__w¬Ç‰r
+ ("fread_unlocked called with bigger size *‚memb�han "
+
+334 
+__ex‹º_®ways_šlše
+ 
+__wur
+ 
+size_t
+
+
+335 
+	$ä—d_uÆocked
+ (*
+__»¡riù
+ 
+__±r
+, 
+size_t
+ 
+__size
+, size_ˆ
+__n
+,
+
+336 
+FILE
+ *
+__»¡riù
+ 
+__¡»am
+)
+
+338 ià(
+	`__bos0
+ (
+__±r
+è!ð(
+size_t
+) -1)
+
+340 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__size
+)
+
+341 || !
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+)
+
+342 || (
+__size
+ | 
+__n
+è>ð(((
+size_t
+) 1) << (8 *  (size_t) / 2)))
+
+343  
+	`__ä—d_uÆocked_chk
+ (
+__±r
+, 
+	`__bos0
+ (__±r), 
+__size
+, 
+__n
+,
+
+344 
+__¡»am
+);
+
+346 ià(
+__size
+ * 
+__n
+ > 
+	`__bos0
+ (
+__±r
+))
+
+347  
+	`__ä—d_uÆocked_chk_w¬n
+ (
+__±r
+, 
+	`__bos0
+ (__±r), 
+__size
+, 
+__n
+,
+
+348 
+__¡»am
+);
+
+351 #ifdeà
+__USE_EXTERN_INLINES
+
+
+352 ià(
+	`__bužtš_cÚ¡ªt_p
+ (
+__size
+)
+
+353 && 
+	`__bužtš_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_g‘c_uÆocked
+ (
+__¡»am
+);
+
+365 ià(
+__c
+ =ð
+EOF
+)
+
+367 *
+__ýŒ
+++ = 
+__c
+;
+
+369  (
+__ýŒ
+ - (*è
+__±r
+è/ 
+__size
+;
+
+372  
+	`__ä—d_uÆocked_®Ÿs
+ (
+__±r
+, 
+__size
+, 
+__n
+, 
+__¡»am
+);
+
+373 
+	}
+}
+
+	@/usr/include/bits/stdio_lim.h
+
+19 #ià!
+defšed
+ 
+_STDIO_H
+ && !defšed 
+__Ãed_FOPEN_MAX
+ && !defšed 
+__Ãed_IOV_MAX
+
+
+23 #ifdeà
+_STDIO_H
+
+
+24 

+	#L_tm²am
+ 20
+
+	)
+
+25 

+	#TMP_MAX
+ 238328
+
+	)
+
+26 

+	#FILENAME_MAX
+ 4096
+
+	)
+
+28 #ifdeà
+__USE_POSIX
+
+
+29 

+	#L_ù”mid
+ 9
+
+	)
+
+30 #ià!
+defšed
+ 
+__USE_XOPEN2K
+ || defšed 
+__USE_GNU
+
+
+31 

+	#L_cu£rid
+ 9
+
+	)
+
+36 #ià
+defšed
+ 
+__Ãed_FOPEN_MAX
+ || defšed 
+_STDIO_H
+
+
+37 #undeà
+FOPEN_MAX
+
+
+38 

+	#FOPEN_MAX
+ 16
+
+	)
+
+41 #ià
+defšed
+ 
+__Ãed_IOV_MAX
+ && !defšed 
+IOV_MAX
+
+
+42 

+	#IOV_MAX
+ 1024
+
+	)
+
+	@/usr/include/bits/sys_errlist.h
+
+20 #iâdeà
+_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 #iâdef 
+_BITS_TYPES_H
+
+
+25 

+	#_BITS_TYPES_H
+ 1
+
+	)
+
+27 
+	~<ã©u»s.h
+>
+
+28 
+	~<b™s/wÜdsize.h
+>
+
+31 
+	t__u_ch¬
+;
+
+32 
+	t__u_shÜt
+;
+
+33 
+	t__u_št
+;
+
+34 
+	t__u_lÚg
+;
+
+37 sigÃd 
+	t__št8_t
+;
+
+38 
+	t__ušt8_t
+;
+
+39 sigÃd 
+	t__št16_t
+;
+
+40 
+	t__ušt16_t
+;
+
+41 sigÃd 
+	t__št32_t
+;
+
+42 
+	t__ušt32_t
+;
+
+43 #ià
+__WORDSIZE
+ == 64
+
+44 sigÃd 
+	t__št64_t
+;
+
+45 
+	t__ušt64_t
+;
+
+46 #–ià
+defšed
+ 
+__GLIBC_HAVE_LONG_LONG
+
+
+47 
+__ex‹nsiÚ__
+ sigÃd 
+	t__št64_t
+;
+
+48 
+__ex‹nsiÚ__
+ 
+	t__ušt64_t
+;
+
+52 #ià
+__WORDSIZE
+ == 64
+
+53 
+	t__quad_t
+;
+
+54 
+	t__u_quad_t
+;
+
+55 #–ià
+defšed
+ 
+__GLIBC_HAVE_LONG_LONG
+
+
+56 
+__ex‹nsiÚ__
+ 
+	t__quad_t
+;
+
+57 
+__ex‹nsiÚ__
+ 
+	t__u_quad_t
+;
+
+61 
+	m__v®
+[2];
+
+62 } 
+	t__quad_t
+;
+
+65 
+__u_lÚg
+ 
+	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
+ 
+__ex‹nsiÚ__
+ 
+
+	)
+
+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 
+	~<b™s/ty³sizes.h
+>
+
+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__u£cÚds_t
+;
+
+151 
+__STD_TYPE
+ 
+__SUSECONDS_T_TYPE
+ 
+	g__su£cÚds_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__blkút_t
+;
+
+170 
+__STD_TYPE
+ 
+__BLKCNT64_T_TYPE
+ 
+	g__blkút64_t
+;
+
+173 
+__STD_TYPE
+ 
+__FSBLKCNT_T_TYPE
+ 
+	g__fsblkút_t
+;
+
+174 
+__STD_TYPE
+ 
+__FSBLKCNT64_T_TYPE
+ 
+	g__fsblkút64_t
+;
+
+177 
+__STD_TYPE
+ 
+__FSFILCNT_T_TYPE
+ 
+	g__fsfžút_t
+;
+
+178 
+__STD_TYPE
+ 
+__FSFILCNT64_T_TYPE
+ 
+	g__fsfžút64_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__sockËn_t
+;
+
+195 #undeà
+__STD_TYPE
+
+
+	@/usr/include/features.h
+
+19 #iâdef 
+_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 #iâdeà
+_LOOSE_KERNEL_NAMES
+
+
+122 

+	#__KERNEL_STRICT_NAMES
+
+
+	)
+
+126 

+	#__USE_ANSI
+ 1
+
+	)
+
+135 #ià
+defšed
+ 
+__GNUC__
+ && defšed 
+__GNUC_MINOR__
+
+
+136 

+	#__GNUC_PREREQ
+(
+maj
+, 
+mš
+) \
+
+137 ((
+__GNUC__
+ << 16è+ 
+__GNUC_MINOR__
+ >ð((
+maj
+è<< 16è+ (
+mš
+))
+
+	)
+
+139 

+	#__GNUC_PREREQ
+(
+maj
+, 
+mš
+è0
+
+	)
+
+144 #ià
+defšed
+ 
+_BSD_SOURCE
+ && \
+
+145 !(
+defšed
+ 
+	g_POSIX_SOURCE
+ || defšed 
+	g_POSIX_C_SOURCE
+ || \
+
+146 
+defšed
+ 
+	g_XOPEN_SOURCE
+ || defšed 
+	g_XOPEN_SOURCE_EXTENDED
+ || \
+
+147 
+defšed
+ 
+	g_GNU_SOURCE
+ || defšed 
+	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à(!
+defšed
+ 
+__STRICT_ANSI__
+ && !defšed 
+_ISOC99_SOURCE
+ && \
+
+176 !
+defšed
+ 
+	g_POSIX_SOURCE
+ && !defšed 
+	g_POSIX_C_SOURCE
+ && \
+
+177 !
+defšed
+ 
+	g_XOPEN_SOURCE
+ && !defšed 
+	g_XOPEN_SOURCE_EXTENDED
+ && \
+
+178 !
+defšed
+ 
+	g_BSD_SOURCE
+ && !defšed 
+	g_SVID_SOURCE
+)
+
+179 

+	#_BSD_SOURCE
+ 1
+
+	)
+
+180 

+	#_SVID_SOURCE
+ 1
+
+	)
+
+187 #ià(
+defšed
+ 
+_ISOC99_SOURCE
+ || defšed 
+_ISOC9X_SOURCE
+ \
+
+188 || (
+defšed
+ 
+	g__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L))
+
+189 

+	#__USE_ISOC99
+ 1
+
+	)
+
+193 #ià(
+defšed
+ 
+_ISOC99_SOURCE
+ || defšed 
+_ISOC9X_SOURCE
+ \
+
+194 || (
+defšed
+ 
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199409L))
+
+195 

+	#__USE_ISOC95
+ 1
+
+	)
+
+200 #ià((!
+defšed
+ 
+__STRICT_ANSI__
+ || (
+_XOPEN_SOURCE
+ - 0) >= 500) && \
+
+201 !
+defšed
+ 
+_POSIX_SOURCE
+ && !defšed 
+_POSIX_C_SOURCE
+)
+
+202 

+	#_POSIX_SOURCE
+ 1
+
+	)
+
+203 #ià
+defšed
+ 
+_XOPEN_SOURCE
+ && (_XOPEN_SOURCE - 0) < 500
+
+204 

+	#_POSIX_C_SOURCE
+ 2
+
+	)
+
+205 #–ià
+defšed
+ 
+_XOPEN_SOURCE
+ && (_XOPEN_SOURCE - 0) < 600
+
+206 

+	#_POSIX_C_SOURCE
+ 199506L
+
+	)
+
+207 #–ià
+defšed
+ 
+_XOPEN_SOURCE
+ && (_XOPEN_SOURCE - 0) < 700
+
+208 

+	#_POSIX_C_SOURCE
+ 200112L
+
+	)
+
+210 

+	#_POSIX_C_SOURCE
+ 200809L
+
+	)
+
+212 

+	#__USE_POSIX_IMPLICITLY
+ 1
+
+	)
+
+215 #ià
+defšed
+ 
+_POSIX_SOURCE
+ || 
+_POSIX_C_SOURCE
+ >ð1 || defšed 
+_XOPEN_SOURCE
+
+
+216 

+	#__USE_POSIX
+ 1
+
+	)
+
+219 #ià
+defšed
+ 
+_POSIX_C_SOURCE
+ && _POSIX_C_SOURCE >ð2 || defšed 
+_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à
+defšed
+ 
+_FILE_OFFSET_BITS
+ && _FILE_OFFSET_BITS == 64
+
+274 

+	#__USE_FILE_OFFSET64
+ 1
+
+	)
+
+277 #ià
+defšed
+ 
+_BSD_SOURCE
+ || defšed 
+_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à
+defšed
+ 
+_REENTRANT
+ || defšed 
+_THREAD_SAFE
+
+
+298 

+	#__USE_REENTRANT
+ 1
+
+	)
+
+301 #ià
+defšed
+ 
+_FORTIFY_SOURCE
+ && _FORTIFY_SOURCE > 0 \
+
+302 && 
+__GNUC_PREREQ
+ (4, 1è&& 
+defšed
+ 
+	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 
+	~<b™s/´edefs.h
+>
+
+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à
+defšed
+ 
+__GNUC__
+ \
+
+337 || (
+defšed
+ 
+	g__PGI
+ && defšed 
+	g__i386__
+ ) \
+
+338 || (
+defšed
+ 
+	g__INTEL_COMPILER
+ && (defšed 
+	g__i386__
+ || defšed 
+	g__Ÿ64__
+)) \
+
+339 || (
+defšed
+ 
+	g__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L)
+
+340 

+	#__GLIBC_HAVE_LONG_LONG
+ 1
+
+	)
+
+344 #iâdeà
+__ASSEMBLER__
+
+
+345 #iâdeà
+_SYS_CDEFS_H
+
+
+346 
+	~<sys/cdefs.h
+>
+
+351 #ià
+defšed
+ 
+__USE_FILE_OFFSET64
+ && !defšed 
+__REDIRECT
+
+
+352 

+	#__USE_LARGEFILE
+ 1
+
+	)
+
+353 

+	#__USE_LARGEFILE64
+ 1
+
+	)
+
+359 #ià
+__GNUC_PREREQ
+ (2, 7è&& 
+defšed
+ 
+__OPTIMIZE__
+ \
+
+360 && !
+defšed
+ 
+	g__OPTIMIZE_SIZE__
+ && !defšed 
+	g__NO_INLINE__
+ \
+
+361 && 
+defšed
+ 
+	g__ex‹º_šlše
+
+
+362 

+	#__USE_EXTERN_INLINES
+ 1
+
+	)
+
+367 #ià
+__GNUC_PREREQ
+ (2, 7è&& 
+defšed
+ 
+__OPTIMIZE__
+ \
+
+368 && (
+defšed
+ 
+	g_LIBC
+ || !defšed 
+	g__OPTIMIZE_SIZE__
+è&& !defšed 
+	g__NO_INLINE__
+ \
+
+369 && 
+defšed
+ 
+	g__ex‹º_šlše
+
+
+370 

+	#__USE_EXTERN_INLINES_IN_LIBC
+ 1
+
+	)
+
+378 
+	~<gnu/¡ubs.h
+>
+
+	@/usr/include/getopt.h
+
+21 #iâdeà
+_GETOPT_H
+
+
+23 #iâdeà
+__Ãed_g‘Ýt
+
+
+24 

+	#_GETOPT_H
+ 1
+
+	)
+
+34 #ià!
+defšed
+ 
+__GNU_LIBRARY__
+
+
+35 
+	~<ùy³.h
+>
+
+38 #iâdeà
+__THROW
+
+
+39 #iâdeà
+__GNUC_PREREQ
+
+
+40 

+	#__GNUC_PREREQ
+(
+maj
+, 
+mš
+è(0)
+
+	)
+
+42 #ià
+defšed
+ 
+__ýlu¥lus
+ && 
+__GNUC_PREREQ
+ (2,8)
+
+43 

+	#__THROW
+ 
+	`throw
+ ()
+
+	)
+
+45 

+	#__THROW
+
+
+	)
+
+49 #ifdef 
+__ýlu¥lus
+
+
+59 
*
+�rg
+;
+
+73 

+Ýtšd
+;
+
+78 

+Ý‹¼
+;
+
+82 

+ÝtÝt
+;
+
+84 #iâdeà
+__Ãed_g‘Ýt
+
+
+106 
+	sÝtiÚ
+
+
+108 cÚ¡ *
+	gÇme
+;
+
+111 
+	ghas_¬g
+;
+
+112 *
+	gæag
+;
+
+113 
+	gv®
+;
+
+118 

+	#no_¬gum’t
+ 0
+
+	)
+
+119 

+	#»quœed_¬gum’t
+ 1
+
+	)
+
+120 

+	#ÝtiÚ®_¬gum’t
+ 2
+
+	)
+
+148 #ifdeà
+__GNU_LIBRARY__
+
+
+152 

+g‘Ýt
+ (
+___¬gc
+, *cÚ¡ *
+___¬gv
+, cÚ¡ *
+__shÜtÝts
+)
+
+153 
+__THROW
+;
+
+155 #ià
+defšed
+ 
+__Ãed_g‘Ýt
+ && defšed 
+__USE_POSIX2
+ \
+
+156 && !
+defšed
+ 
+	g__USE_POSIX_IMPLICITLY
+ && !defšed 
+	g__USE_GNU
+
+
+160 #ifdeà
+__REDIRECT
+
+
+161 

+__REDIRECT
+ (
+g‘Ýt
+, (
+___¬gc
+, *cÚ¡ *
+___¬gv
+,
+
+162 cÚ¡ *
+__shÜtÝts
+),
+
+163 
+__posix_g‘Ýt
+è
+__THROW
+;
+
+165 

+__posix_g‘Ýt
+ (
+___¬gc
+, *cÚ¡ *
+___¬gv
+,
+
+166 cÚ¡ *
+__shÜtÝts
+è
+__THROW
+;
+
+167 

+	#g‘Ýt
+ 
+__posix_g‘Ýt
+
+
+	)
+
+171 

+g‘Ýt
+ ();
+
+174 #iâdeà
+__Ãed_g‘Ýt
+
+
+175 

+g‘Ýt_lÚg
+ (
+___¬gc
+, *cÚ¡ *
+___¬gv
+,
+
+176 cÚ¡ *
+__shÜtÝts
+,
+
+177 cÚ¡ 
+ÝtiÚ
+ *
+__lÚgÝts
+, *
+__lÚgšd
+)
+
+178 
+__THROW
+;
+
+179 

+g‘Ýt_lÚg_Úly
+ (
+___¬gc
+, *cÚ¡ *
+___¬gv
+,
+
+180 cÚ¡ *
+__shÜtÝts
+,
+
+181 cÚ¡ 
+ÝtiÚ
+ *
+__lÚgÝts
+, *
+__lÚgšd
+)
+
+182 
+__THROW
+;
+
+186 #ifdef 
+__ýlu¥lus
+
+
+191 #undeà
+__Ãed_g‘Ýt
+
+
+	@/usr/include/libio.h
+
+29 #iâdeà
+_IO_STDIO_H
+
+
+30 

+	#_IO_STDIO_H
+
+
+	)
+
+32 
+	~<_G_cÚfig.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_icÚv_t
+ 
+_G_icÚv_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_wšt_t
+ 
+_G_wšt_t
+
+
+	)
+
+50 #ifdeà
+_G_NEED_STDARG_H
+
+
+52 

+	#__Ãed___va_li¡
+
+
+	)
+
+53 
+	~<¡d¬g.h
+>
+
+54 #ifdeà
+__GNUC_VA_LIST
+
+
+55 #undeà
+_IO_va_li¡
+
+
+56 

+	#_IO_va_li¡
+ 
+__gnuc_va_li¡
+
+
+	)
+
+60 #iâdeà
+__P
+
+
+61 #ià
+_G_HAVE_SYS_CDEFS
+
+
+62 
+	~<sys/cdefs.h
+>
+
+64 #ifdeà
+__STDC__
+
+
+65 

+	#__P
+(
+p
+è
+	)
+p
+
+66 

+	#__PMT
+(
+p
+è
+	)
+p
+
+68 

+	#__P
+(
+p
+è()
+
+	)
+
+69 

+	#__PMT
+(
+p
+è()
+
+	)
+
+75 #iâdeà
+_PARAMS
+
+
+76 

+	#_PARAMS
+(
+´Ùos
+è
+	`__P
+ÕrÙos)
+
+	)
+
+79 #iâdeà
+__STDC__
+
+
+81 
cÚ¡
+
+	)
+
+84 

+	#_IO_UNIFIED_JUMPTABLES
+ 1
+
+	)
+
+85 #iâdeà
+_G_HAVE_PRINTF_FP
+
+
+86 

+	#_IO_USE_DTOA
+ 1
+
+	)
+
+89 #iâdeà
+EOF
+
+
+90 

+	#EOF
+ (-1)
+
+	)
+
+92 #iâdeà
+NULL
+
+
+93 #ià
+defšed
+ 
+__GNUG__
+ && \
+
+94 (
+	g__GNUC__
+ > 2 || (__GNUC__ =ð2 && 
+__GNUC_MINOR__
+ >= 8))
+
+95 

+	#NULL
+ (
+__nuÎ
+)
+
+	)
+
+97 #ià!
+defšed
+(
+__ýlu¥lus
+)
+
+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à
+defšed
+ 
+__GLIBC__
+ && __GLIBC__ >= 2
+
+175 
+	~<b™s/¡dio-lock.h
+>
+
+180 
+	t_IO_lock_t
+;
+
+186 
+	s_IO_m¬k”
+ {
+
+187 
+_IO_m¬k”
+ *
+	m_Ãxt
+;
+
+188 
+_IO_FILE
+ *
+	m_sbuf
+;
+
+192 
+	m_pos
+;
+
+194 
+£t_¡»ampos
+(
+¡»ampos
+ 
+¥
+è{ 
+	m_¥os
+ = sp; }
+
+195 
+£t_off£t
+(
+off£t
+è{ 
+	m_pos
+ = off£t; 
+	m_¥os
+ = (
+¡»ampos
+)(-2); }
+
+196 
+	mpublic
+:
+
+197 
+¡»amm¬k”
+(
+¡»ambuf
+ *
+sb
+);
+
+198 ~
+¡»amm¬k”
+();
+
+199 
+§všg
+(è{  
+	m_¥os
+ == -2; }
+
+200 
+d–�
+(
+¡»amm¬k”
+&);
+
+201 
+d–�
+();
+
+206 
+	e__codecvt_»suÉ
+
+
+208 
+	m__codecvt_ok
+,
+
+209 
+	m__codecvt_·¹Ÿl
+,
+
+210 
+	m__codecvt_”rÜ
+,
+
+211 
+	m__codecvt_nocÚv
+
+
+214 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+217 
+	s_IO_codecvt
+
+
+219 (*
+	m__codecvt_de¡r
+è(
+	m_IO_codecvt
+ *);
+
+220 
+__codecvt_»suÉ
+ (*
+__codecvt_do_out
+è(
+	m_IO_codecvt
+ *,
+
+221 
+	m__mb¡©e_t
+ *,
+
+222 cÚ¡ 
+	mwch¬_t
+ *,
+
+223 cÚ¡ 
+	mwch¬_t
+ *,
+
+224 cÚ¡ 
+	mwch¬_t
+ **, *,
+
+226 
+__codecvt_»suÉ
+ (*
+__codecvt_do_unshiá
+è(
+	m_IO_codecvt
+ *,
+
+227 
+	m__mb¡©e_t
+ *, *,
+
+229 
+__codecvt_»suÉ
+ (*
+__codecvt_do_š
+è(
+	m_IO_codecvt
+ *,
+
+230 
+	m__mb¡©e_t
+ *,
+
+232 cÚ¡ **, 
+	mwch¬_t
+ *,
+
+233 
+	mwch¬_t
+ *, wchar_t **);
+
+234 (*
+	m__codecvt_do_’codšg
+è(
+	m_IO_codecvt
+ *);
+
+235 (*
+	m__codecvt_do_®ways_nocÚv
+è(
+	m_IO_codecvt
+ *);
+
+236 (*
+	m__codecvt_do_Ëngth
+è(
+	m_IO_codecvt
+ *, 
+	m__mb¡©e_t
+ *,
+
+237 cÚ¡ *, cÚ¡ *, 
+	m_IO_size_t
+);
+
+238 (*
+	m__codecvt_do_max_Ëngth
+è(
+	m_IO_codecvt
+ *);
+
+240 
+_IO_icÚv_t
+ 
+	m__cd_š
+;
+
+241 
+_IO_icÚv_t
+ 
+	m__cd_out
+;
+
+245 
+	s_IO_wide_d©a
+
+
+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_wr™e_ba£
+;
+
+251 
+wch¬_t
+ *
+	m_IO_wr™e_±r
+;
+
+252 
+wch¬_t
+ *
+	m_IO_wr™e_’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 
+__mb¡©e_t
+ 
+	m_IO_¡©e
+;
+
+262 
+__mb¡©e_t
+ 
+	m_IO_Ï¡_¡©e
+;
+
+263 
+_IO_codecvt
+ 
+	m_codecvt
+;
+
+265 
+wch¬_t
+ 
+	m_shÜtbuf
+[1];
+
+267 cÚ¡ 
+_IO_jump_t
+ *
+	m_wide_v�bË
+;
+
+271 
+	s_IO_FILE
+ {
+
+272 
+	m_æags
+;
+
+273 

+	#_IO_fže_æags
+ 
+_æags
+
+
+	)
+
+277 * 
+	m_IO_»ad_±r
+;
+
+278 * 
+	m_IO_»ad_’d
+;
+
+279 * 
+	m_IO_»ad_ba£
+;
+
+280 * 
+	m_IO_wr™e_ba£
+;
+
+281 * 
+	m_IO_wr™e_±r
+;
+
+282 * 
+	m_IO_wr™e_’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_m¬k”
+ *
+	m_m¬k”s
+;
+
+292 
+_IO_FILE
+ *
+	m_chaš
+;
+
+294 
+	m_fž’o
+;
+
+296 
+	m_blksize
+;
+
+298 
+	m_æags2
+;
+
+300 
+_IO_off_t
+ 
+	m_Þd_off£t
+;
+
+302 

+	#__HAVE_COLUMN
+
+
+	)
+
+304 
+	m_cur_cÞumn
+;
+
+305 sigÃd 
+	m_v�bË_off£t
+;
+
+306 
+	m_shÜtbuf
+[1];
+
+310 
+_IO_lock_t
+ *
+	m_lock
+;
+
+311 #ifdeà
+_IO_USE_OLD_IO_FILE
+
+
+314 
+	s_IO_FILE_com¶‘e
+
+
+316 
+_IO_FILE
+ 
+	m_fže
+;
+
+318 #ià
+defšed
+ 
+_G_IO_IO_FILE_VERSION
+ && _G_IO_IO_FILE_VERSION == 0x20001
+
+319 
+_IO_off64_t
+ 
+	m_off£t
+;
+
+320 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+322 
+_IO_codecvt
+ *
+	m_codecvt
+;
+
+323 
+_IO_wide_d©a
+ *
+	m_wide_d©a
+;
+
+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_unu£d2
+[15 *  (è- 4 *  (*è-  (
+size_t
+)];
+
+340 #iâdeà
+__ýlu¥lus
+
+
+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_¡d”r_
+;
+
+349 #iâdeà
+_LIBC
+
+
+350 

+	#_IO_¡dš
+ ((
+_IO_FILE
+*)(&
+_IO_2_1_¡dš_
+))
+
+	)
+
+351 

+	#_IO_¡dout
+ ((
+_IO_FILE
+*)(&
+_IO_2_1_¡dout_
+))
+
+	)
+
+352 

+	#_IO_¡d”r
+ ((
+_IO_FILE
+*)(&
+_IO_2_1_¡d”r_
+))
+
+	)
+
+354 

+_IO_FILE
+ *
+_IO_¡dš
+ 
+©Œibu‹_hidd’
+;
+
+355 

+_IO_FILE
+ *
+_IO_¡dout
+ 
+©Œibu‹_hidd’
+;
+
+356 

+_IO_FILE
+ *
+_IO_¡d”r
+ 
+©Œibu‹_hidd’
+;
+
+364 
+__ssize_t
+ 
+	t__io_»ad_â
+ (*
+	t__cook›
+, *
+	t__buf
+, 
+	tsize_t
+ 
+	t__nby‹s
+);
+
+372 
+__ssize_t
+ 
+	t__io_wr™e_â
+ (*
+	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_funùiÚ_t
+;
+
+390 
+__io_wr™e_â
+ 
+	tcook›_wr™e_funùiÚ_t
+;
+
+391 
+__io_£ek_â
+ 
+	tcook›_£ek_funùiÚ_t
+;
+
+392 
+__io_þo£_â
+ 
+	tcook›_þo£_funùiÚ_t
+;
+
+397 
+__io_»ad_â
+ *
+	m»ad
+;
+
+398 
+__io_wr™e_â
+ *
+	mwr™e
+;
+
+399 
+__io_£ek_â
+ *
+	m£ek
+;
+
+400 
+__io_þo£_â
+ *
+	mþo£
+;
+
+401 } 
+	t_IO_cook›_io_funùiÚs_t
+;
+
+402 
+_IO_cook›_io_funùiÚs_t
+ 
+	tcook›_io_funùiÚs_t
+;
+
+404 
+	g_IO_cook›_fže
+;
+
+407 

+_IO_cook›_š™
+ (
+_IO_cook›_fže
+ *
+__cfže
+, 
+__»ad_wr™e
+,
+
+408 *
+__cook›
+, 
+_IO_cook›_io_funùiÚs_t
+ 
+__âs
+);
+
+412 #ifdeà
+__ýlu¥lus
+
+
+416 

+__undӾow
+ (
+_IO_FILE
+ *);
+
+417 

+__uæow
+ (
+_IO_FILE
+ *);
+
+418 

+__ovӾow
+ (
+_IO_FILE
+ *, );
+
+419 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+420 

+_IO_wšt_t
+ 
+__wundӾow
+ (
+_IO_FILE
+ *);
+
+421 

+_IO_wšt_t
+ 
+__wuæow
+ (
+_IO_FILE
+ *);
+
+422 

+_IO_wšt_t
+ 
+__wovӾow
+ (
+_IO_FILE
+ *, _IO_wint_t);
+
+425 #ià 
+__GNUC__
+ >= 3
+
+426 

+	#_IO_BE
+(
+ex´
+, 
+»s
+è
+	`__bužtš_ex³ù
+ (Óx´),„es)
+
+	)
+
+428 

+	#_IO_BE
+(
+ex´
+, 
+»s
+èÓx´)
+
+	)
+
+431 

+	#_IO_g‘c_uÆocked
+(
+_å
+) \
+
+432 (
+	`_IO_BE
+ ((
+_å
+)->
+_IO_»ad_±r
+ >ð(_å)->
+_IO_»ad_’d
+, 0) \
+
+433 ? 
+	`__uæow
+ (
+_å
+è: *(*è(_å)->
+_IO_»ad_±r
+++)
+
+	)
+
+434 

+	#_IO_³ekc_uÆocked
+(
+_å
+) \
+
+435 (
+	`_IO_BE
+ ((
+_å
+)->
+_IO_»ad_±r
+ >ð(_å)->
+_IO_»ad_’d
+, 0) \
+
+436 && 
+	`__undӾow
+ (
+_å
+è=ð
+EOF
+ ? EOF \
+
+437 : *(*è(
+_å
+)->
+_IO_»ad_±r
+)
+
+	)
+
+438 

+	#_IO_putc_uÆocked
+(
+_ch
+, 
+_å
+) \
+
+439 (
+	`_IO_BE
+ ((
+_å
+)->
+_IO_wr™e_±r
+ >ð(_å)->
+_IO_wr™e_’d
+, 0) \
+
+440 ? 
+	`__ovӾow
+ (
+_å
+, (è(
+_ch
+)) \
+
+441 : (è(*(
+_å
+)->
+_IO_wr™e_±r
+++ = (
+_ch
+)))
+
+	)
+
+443 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+444 

+	#_IO_g‘wc_uÆocked
+(
+_å
+) \
+
+445 (
+	`_IO_BE
+ ((
+_å
+)->
+_wide_d©a
+ =ð
+NULL
+ \
+
+446 || ((
+_å
+)->
+_wide_d©a
+->
+_IO_»ad_±r
+ \
+
+447 >ð(
+_å
+)->
+_wide_d©a
+->
+_IO_»ad_’d
+), 0) \
+
+448 ? 
+	`__wuæow
+ (
+_å
+è: (
+_IO_wšt_t
+è*(_å)->
+_wide_d©a
+->
+_IO_»ad_±r
+++)
+
+	)
+
+449 

+	#_IO_putwc_uÆocked
+(
+_wch
+, 
+_å
+) \
+
+450 (
+	`_IO_BE
+ ((
+_å
+)->
+_wide_d©a
+ =ð
+NULL
+ \
+
+451 || ((
+_å
+)->
+_wide_d©a
+->
+_IO_wr™e_±r
+ \
+
+452 >ð(
+_å
+)->
+_wide_d©a
+->
+_IO_wr™e_’d
+), 0) \
+
+453 ? 
+	`__wovӾow
+ (
+_å
+, 
+_wch
+) \
+
+454 : (
+_IO_wšt_t
+è(*(
+_å
+)->
+_wide_d©a
+->
+_IO_wr™e_±r
+++ = (
+_wch
+)))
+
+	)
+
+457 

+	#_IO_ãof_uÆocked
+(
+__å
+è(((__å)->
+_æags
+ & 
+_IO_EOF_SEEN
+è!ð0)
+
+	)
+
+458 

+	#_IO_ã¼Ü_uÆocked
+(
+__å
+è(((__å)->
+_æags
+ & 
+_IO_ERR_SEEN
+è!ð0)
+
+	)
+
+460 

+_IO_g‘c
+ (
+_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_wr™e_±r
+ - (_å)->
+_IO_wr™e_ba£
+)
+
+	)
+
+471 

+_IO_æockfže
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+472 

+_IO_fuÆockfže
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+473 

+_IO_árylockfže
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+475 #ifdeà
+_IO_MTSAFE_IO
+
+
+476 

+	#_IO_³ekc
+(
+_å
+è
+	`_IO_³ekc_locked
+ (_å)
+
+	)
+
+477 

+	#_IO_æockfže
+(
+_å
+) \
+
+478 ià(((
+_å
+)->
+_æags
+ & 
+_IO_USER_LOCK
+è=ð0è
+	`_IO_æockfže
+ (_å)
+
+	)
+
+479 

+	#_IO_fuÆockfže
+(
+_å
+) \
+
+480 ià(((
+_å
+)->
+_æags
+ & 
+_IO_USER_LOCK
+è=ð0è
+	`_IO_fuÆockfže
+ (_å)
+
+	)
+
+482 

+	#_IO_³ekc
+(
+_å
+è
+	`_IO_³ekc_uÆocked
+ (_å)
+
+	)
+
+483 

+	#_IO_æockfže
+(
+_å
+è
+
+	)
+
+484 

+	#_IO_fuÆockfže
+(
+_å
+è
+
+	)
+
+485 

+	#_IO_árylockfže
+(
+_å
+è
+
+	)
+
+486 

+	#_IO_þ—nup_»giÚ_¡¬t
+(
+_fù
+, 
+_å
+è
+
+	)
+
+487 

+	#_IO_þ—nup_»giÚ_’d
+(
+_Do™
+è
+
+	)
+
+490 

+_IO_vfsÿnf
+ (
+_IO_FILE
+ * 
+__»¡riù
+, const * __restrict,
+
+491 
+_IO_va_li¡
+, *
+__»¡riù
+);
+
+492 

+_IO_vårštf
+ (
+_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_sg‘n
+ (
+_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à
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+503 

+_IO_wšt_t
+ 
+_IO_g‘wc
+ (
+_IO_FILE
+ *
+__å
+);
+
+504 

+_IO_wšt_t
+ 
+_IO_putwc
+ (
+wch¬_t
+ 
+__wc
+, 
+_IO_FILE
+ *
+__å
+);
+
+505 

+_IO_fwide
+ (
+_IO_FILE
+ *
+__å
+, 
+__mode
+è
+__THROW
+;
+
+506 #ià
+__GNUC__
+ >= 2
+
+509 #ià
+defšed
+ 
+_LIBC
+ && defšed 
+SHARED
+
+
+510 
+	~<shlib-com·t.h
+>
+
+511 #ià
+SHLIB_COMPAT
+ (
+libc
+, 
+GLIBC_2_0
+, 
+GLIBC_2_1
+)
+
+512 

+	#_IO_fwide_maybe_šcom·tibË
+ \
+
+513 (
+	`__bužtš_ex³ù
+ (&
+_IO_¡dš_u£d
+ =ð
+NULL
+, 0))
+
+	)
+
+514 
cÚ¡ 
+_IO_¡dš_u£d
+;
+
+515 
+w—k_ex‹º
+ (
+_IO_¡dš_u£d
+);
+
+518 #iâdeà
+_IO_fwide_maybe_šcom·tibË
+
+
+519 

+	#_IO_fwide_maybe_šcom·tibË
+ (0)
+
+	)
+
+523 

+	#_IO_fwide
+(
+__å
+, 
+__mode
+) \
+
+524 ({ 
+__»suÉ
+ = (
+__mode
+); \
+
+525 ià(
+__»suÉ
+ < 0 && ! 
+_IO_fwide_maybe_šcom·tibË
+) \
+
+527 ià((
+__å
+)->
+_mode
+ == 0) \
+
+529 (
+__å
+)->
+_mode
+ = -1; \
+
+530 
+__»suÉ
+ = (
+__å
+)->
+_mode
+; \
+
+532 ià(
+	`__bužtš_cÚ¡ªt_p
+ (
+__mode
+) && (__mode) == 0) \
+
+533 
+__»suÉ
+ = 
+_IO_fwide_maybe_šcom·tibË
+ ? -1 : (
+__å
+)->
+_mode
+; \
+
+535 
+__»suÉ
+ = 
+	`_IO_fwide
+ (
+__å
+, __result); \
+
+536 
+__»suÉ
+; })
+
+	)
+
+539 

+_IO_vfwsÿnf
+ (
+_IO_FILE
+ * 
+__»¡riù
+, cÚ¡ 
+wch¬_t
+ * __restrict,
+
+540 
+_IO_va_li¡
+, *
+__»¡riù
+);
+
+541 

+_IO_vfw´štf
+ (
+_IO_FILE
+ *
+__»¡riù
+, cÚ¡ 
+wch¬_t
+ *__restrict,
+
+542 
+_IO_va_li¡
+);
+
+543 

+_IO_ssize_t
+ 
+_IO_w·dn
+ (
+_IO_FILE
+ *, 
+wšt_t
+, _IO_ssize_t);
+
+544 

+_IO_ä“_wbackup_¬—
+ (
+_IO_FILE
+ *è
+__THROW
+;
+
+547 #ifdeà
+__LDBL_COMPAT
+
+
+548 
+	~<b™s/libio-ldbl.h
+>
+
+551 #ifdeà
+__ýlu¥lus
+
+
+	@/usr/include/_G_config.h
+
+4 #iâdeà
+_G_cÚfig_h
+
+
+5 

+	#_G_cÚfig_h
+ 1
+
+	)
+
+9 
+	~<b™s/ty³s.h
+>
+
+10 

+	#__Ãed_size_t
+
+
+	)
+
+11 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+12 

+	#__Ãed_wch¬_t
+
+
+	)
+
+14 

+	#__Ãed_NULL
+
+
+	)
+
+15 
+	~<¡ddef.h
+>
+
+16 

+	#__Ãed_mb¡©e_t
+
+
+	)
+
+17 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+18 

+	#__Ãed_wšt_t
+
+
+	)
+
+20 
+	~<wch¬.h
+>
+
+21 

+	#_G_size_t
+ 
+size_t
+
+
+	)
+
+24 
+__off_t
+ 
+	m__pos
+;
+
+25 
+__mb¡©e_t
+ 
+	m__¡©e
+;
+
+26 } 
+	t_G_åos_t
+;
+
+29 
+__off64_t
+ 
+	m__pos
+;
+
+30 
+__mb¡©e_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_wšt_t
+ 
+wšt_t
+
+
+	)
+
+39 

+	#_G_¡©64
+ 
+¡©64
+
+
+	)
+
+40 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_GLIBCPP_USE_WCHAR_T
+
+
+41 
+	~<gcÚv.h
+>
+
+44 
+__gcÚv_šfo
+ 
+	m__cd
+;
+
+47 
+__gcÚv_šfo
+ 
+	m__cd
+;
+
+48 
+__gcÚv_¡•_d©a
+ 
+	m__d©a
+;
+
+49 } 
+	m__combšed
+;
+
+50 } 
+	t_G_icÚv_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_ušt16_t
+ 
+	t__©Œibu‹__
+ ((
+	t__mode__
+ (
+	t__HI__
+)));
+
+56 
+	t_G_ušt32_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
+ 
+__l£ek64
+
+
+	)
+
+79 

+	#_G_MMAP64
+ 
+__mm­64
+
+
+	)
+
+80 

+	#_G_FSTAT64
+(
+fd
+,
+buf
+è
+	`__fx¡©64
+ (
+_STAT_VER
+, fd, buf)
+
+	)
+
+83 

+	#_G_HAVE_ST_BLKSIZE
+ 
+	`defšed
+ (
+_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à
+defšed
+ 
+__ýlu¥lus
+ || defšed 
+__STDC__
+
+
+96 

+	#_G_ARGS
+(
+ARGLIST
+è
+	)
+ARGLIST
+
+98 

+	#_G_ARGS
+(
+ARGLIST
+è()
+
+	)
+
+	@/usr/include/bits/libio-ldbl.h
+
+20 #iâdeà
+_IO_STDIO_H
+
+
+24 
+	$__LDBL_REDIR_DECL
+ (
+_IO_vfsÿnf
+)
+
+25 
+	`__LDBL_REDIR_DECL
+ (
+_IO_vårštf
+)
+
+	@/usr/include/bits/predefs.h
+
+19 #iâdeà
+_FEATURES_H
+
+
+23 #iâdeà
+_PREDEFS_H
+
+
+24 

+	#_PREDEFS_H
+
+
+	)
+
+27 

+	#__STDC_IEC_559__
+ 1
+
+	)
+
+28 

+	#__STDC_IEC_559_COMPLEX__
+ 1
+
+	)
+
+	@/usr/include/bits/stdio-lock.h
+
+20 #iâdeà
+_BITS_STDIO_LOCK_H
+
+
+21 

+	#_BITS_STDIO_LOCK_H
+ 1
+
+	)
+
+23 
+	~<b™s/libc-lock.h
+>
+
+24 
+	~<lowËv–lock.h
+>
+
+28 

+	#_IO_lock_šex³nsive
+ 1
+
+	)
+
+30 ¡ruù { 
+	mlock
+; 
+	mút
+; *
+	mowÃr
+; } 
+	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_fši
+(
+_Çme
+) \
+
+38 ((è0)
+
+	)
+
+40 

+	#_IO_lock_lock
+(
+_Çme
+) \
+
+42 *
+__£lf
+ = 
+THREAD_SELF
+; \
+
+43 ià((
+_Çme
+).
+owÃr
+ !ð
+__£lf
+) \
+
+45 
+	`Îl_lock
+ ((
+_Çme
+).
+lock
+, 
+LLL_PRIVATE
+); \
+
+46 (
+_Çme
+).
+owÃr
+ = 
+__£lf
+; \
+
+48 ++(
+_Çme
+).
+út
+; \
+
+49 } 0)
+
+	)
+
+51 

+	#_IO_lock_Œylock
+(
+_Çme
+) \
+
+53 
+__»suÉ
+ = 0; \
+
+54 *
+__£lf
+ = 
+THREAD_SELF
+; \
+
+55 ià((
+_Çme
+).
+owÃr
+ !ð
+__£lf
+) \
+
+57 ià(
+	`Îl_Œylock
+ ((
+_Çme
+).
+lock
+) == 0) \
+
+59 (
+_Çme
+).
+owÃr
+ = 
+__£lf
+; \
+
+60 (
+_Çme
+).
+út
+ = 1; \
+
+63 
+__»suÉ
+ = 
+EBUSY
+; \
+
+66 ++(
+_Çme
+).
+út
+; \
+
+67 
+__»suÉ
+; \
+
+68 })
+
+	)
+
+70 

+	#_IO_lock_uÆock
+(
+_Çme
+) \
+
+72 ià(--(
+_Çme
+).
+út
+ == 0) \
+
+74 (
+_Çme
+).
+owÃr
+ = 
+NULL
+; \
+
+75 
+	`Îl_uÆock
+ ((
+_Ç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_nßrg
+(
+_fù
+) \
+
+84 
+	`__libc_þ—nup_»giÚ_¡¬t
+ (1, 
+_fù
+, 
+NULL
+)
+
+	)
+
+85 

+	#_IO_þ—nup_»giÚ_’d
+(
+_do™
+) \
+
+86 
+	`__libc_þ—nup_»giÚ_’d
+ (
+_do™
+)
+
+	)
+
+88 #ià
+defšed
+ 
+_LIBC
+ && !defšed 
+NOT_IN_libc
+
+
+90 #ifdeà
+__EXCEPTIONS
+
+
+91 

+	#_IO_acquœe_lock
+(
+_å
+) \
+
+93 
+_IO_FILE
+ *
+_IO_acquœe_lock_fže
+ \
+
+94 
+	`__©Œibu‹__
+((
+	`þ—nup
+ (
+_IO_acquœe_lock_fù
+))) \
+
+95 ð(
+_å
+); \
+
+96 
+	`_IO_æockfže
+ (
+_IO_acquœe_lock_fže
+);
+
+	)
+
+97 

+	#_IO_acquœe_lock_þ—r_æags2
+(
+_å
+) \
+
+99 
+_IO_FILE
+ *
+_IO_acquœe_lock_fže
+ \
+
+100 
+	`__©Œibu‹__
+((
+	`þ—nup
+ (
+_IO_acquœe_lock_þ—r_æags2_fù
+))) \
+
+101 ð(
+_å
+); \
+
+102 
+	`_IO_æockfže
+ (
+_IO_acquœe_lock_fže
+);
+
+	)
+
+104 

+	#_IO_acquœe_lock
+(
+_å
+è
+_IO_acquœe_lock_Ãeds_exû±iÚs_’abËd
+
+
+	)
+
+105 

+	#_IO_acquœe_lock_þ—r_æags2
+(
+_å
+è
+	`_IO_acquœe_lock
+ (_å)
+
+	)
+
+107 

+	#_IO_»Ëa£_lock
+(
+_å
+è; } 0)
+
+	)
+
+	@/usr/include/bits/typesizes.h
+
+20 #iâdeà
+_BITS_TYPES_H
+
+
+24 #iâdef 
+_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
+ sŒuù { 
+__v®
+[2]; }
+
+	)
+
+60 

+	#__SSIZE_T_TYPE
+ 
+__SWORD_TYPE
+
+
+	)
+
+63 

+	#__FD_SETSIZE
+ 1024
+
+	)
+
+	@/usr/include/bits/wordsize.h
+
+3 #ià
+defšed
+ 
+__x86_64__
+
+
+4 

+	#__WORDSIZE
+ 64
+
+	)
+
+5 

+	#__WORDSIZE_COMPAT32
+ 1
+
+	)
+
+7 

+	#__WORDSIZE
+ 32
+
+	)
+
+	@/usr/include/ctype.h
+
+24 #iâdef 
+_CTYPE_H
+
+
+25 

+	#_CTYPE_H
+ 1
+
+	)
+
+27 
+	~<ã©u»s.h
+>
+
+28 
+	~<b™s/ty³s.h
+>
+
+30 
+	g__BEGIN_DECLS
+
+
+32 #iâdeà
+_ISb™
+
+
+41 
+	~<’dŸn.h
+>
+
+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_IS®pha
+ = 
+_ISb™
+ (2),
+
+53 
+	m_ISdig™
+ = 
+_ISb™
+ (3),
+
+54 
+	m_ISxdig™
+ = 
+_ISb™
+ (4),
+
+55 
+	m_IS¥aû
+ = 
+_ISb™
+ (5),
+
+56 
+	m_IS´št
+ = 
+_ISb™
+ (6),
+
+57 
+	m_ISg¿ph
+ = 
+_ISb™
+ (7),
+
+58 
+	m_ISbÏnk
+ = 
+_ISb™
+ (8),
+
+59 
+	m_ISúŒl
+ = 
+_ISb™
+ (9),
+
+60 
+	m_ISpunù
+ = 
+_ISb™
+ (10),
+
+61 
+	m_IS®num
+ = 
+_ISb™
+ (11)
+
+81 

+__cÚ¡
+ **
+	$__ùy³_b_loc
+ ()
+
+82 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡
+));
+
+83 

+__cÚ¡
+ 
+__št32_t
+ **
+	$__ùy³_tÞow”_loc
+ ()
+
+84 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡
+));
+
+85 

+__cÚ¡
+ 
+__št32_t
+ **
+	$__ùy³_touµ”_loc
+ ()
+
+86 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡
+));
+
+88 

+	#__isùy³
+(
+c
+, 
+ty³
+) \
+
+89 ((*
+	`__ùy³_b_loc
+ ())[(è(
+c
+)] & (è
+ty³
+)
+
+	)
+
+91 

+	#__i§scii
+(
+c
+è(((cè& ~0x7fè=ð0è
+
+	)
+
+92 

+	#__tßscii
+(
+c
+è((cè& 0x7fè
+
+	)
+
+94 

+	#__exùy³
+(
+Çme
+è

+	`Çme
+ (è
+__THROW
+
+
+	)
+
+96 
+__BEGIN_NAMESPACE_STD
+
+
+102 
+	`__exùy³
+ (
+i§Êum
+);
+
+103 
+	`__exùy³
+ (
+i§Íha
+);
+
+104 
+	`__exùy³
+ (
+isúŒl
+);
+
+105 
+	`__exùy³
+ (
+isdig™
+);
+
+106 
+	`__exùy³
+ (
+i¦ow”
+);
+
+107 
+	`__exùy³
+ (
+isg¿ph
+);
+
+108 
+	`__exùy³
+ (
+i¥ršt
+);
+
+109 
+	`__exùy³
+ (
+i¥unù
+);
+
+110 
+	`__exùy³
+ (
+is¥aû
+);
+
+111 
+	`__exùy³
+ (
+isuµ”
+);
+
+112 
+	`__exùy³
+ (
+isxdig™
+);
+
+116 

+	$tÞow”
+ (
+__c
+è
+__THROW
+;
+
+119 

+	$touµ”
+ (
+__c
+è
+__THROW
+;
+
+121 
+__END_NAMESPACE_STD
+
+
+125 #ifdef 
+__USE_ISOC99
+
+
+126 
+__BEGIN_NAMESPACE_C99
+
+
+128 
+	`__exùy³
+ (
+isbÏnk
+);
+
+130 
+__END_NAMESPACE_C99
+
+
+133 #ifdeà
+__USE_GNU
+
+
+135 

+	$isùy³
+ (
+__c
+, 
+__mask
+è
+__THROW
+;
+
+138 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_MISC
+ || defšed 
+__USE_XOPEN
+
+
+142 

+	$i§scii
+ (
+__c
+è
+__THROW
+;
+
+146 

+	$tßscii
+ (
+__c
+è
+__THROW
+;
+
+150 
+	`__exùy³
+ (
+_touµ”
+);
+
+151 
+	`__exùy³
+ (
+_tÞow”
+);
+
+155 

+	#__tobody
+(
+c
+, 
+f
+, 
+a
+, 
+¬gs
+) \
+
+156 (
+__ex‹nsiÚ__
+ \
+
+157 ({ 
+__»s
+; \
+
+158 ià( (
+c
+) > 1) \
+
+160 ià(
+	`__bužtš_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à!
+defšed
+ 
+__NO_CTYPE
+ && !defšed 
+__ýlu¥lus
+
+
+173 

+	#i§Êum
+(
+c
+è
+	`__isùy³
+((c), 
+_IS®num
+)
+
+	)
+
+174 

+	#i§Íha
+(
+c
+è
+	`__isùy³
+((c), 
+_IS®pha
+)
+
+	)
+
+175 

+	#isúŒl
+(
+c
+è
+	`__isùy³
+((c), 
+_ISúŒl
+)
+
+	)
+
+176 

+	#isdig™
+(
+c
+è
+	`__isùy³
+((c), 
+_ISdig™
+)
+
+	)
+
+177 

+	#i¦ow”
+(
+c
+è
+	`__isùy³
+((c), 
+_ISlow”
+)
+
+	)
+
+178 

+	#isg¿ph
+(
+c
+è
+	`__isùy³
+((c), 
+_ISg¿ph
+)
+
+	)
+
+179 

+	#i¥ršt
+(
+c
+è
+	`__isùy³
+((c), 
+_IS´št
+)
+
+	)
+
+180 

+	#i¥unù
+(
+c
+è
+	`__isùy³
+((c), 
+_ISpunù
+)
+
+	)
+
+181 

+	#is¥aû
+(
+c
+è
+	`__isùy³
+((c), 
+_IS¥aû
+)
+
+	)
+
+182 

+	#isuµ”
+(
+c
+è
+	`__isùy³
+((c), 
+_ISuµ”
+)
+
+	)
+
+183 

+	#isxdig™
+(
+c
+è
+	`__isùy³
+((c), 
+_ISxdig™
+)
+
+	)
+
+185 #ifdeà
+__USE_ISOC99
+
+
+186 

+	#isbÏnk
+(
+c
+è
+	`__isùy³
+((c), 
+_ISbÏnk
+)
+
+	)
+
+189 #ifdeà
+__USE_EXTERN_INLINES
+
+
+190 
+__ex‹º_šlše
+ 
+
+191 
+__NTH
+ (
+	$tÞow”
+ (
+__c
+))
+
+193  
+__c
+ >ð-128 && __ø< 256 ? (*
+	`__ùy³_tÞow”_loc
+ ())[__c] : __c;
+
+194 
+	}
+}
+
+196 
+__ex‹º_šlše
+ 
+
+197 
+__NTH
+ (
+	$touµ”
+ (
+__c
+))
+
+199  
+__c
+ >ð-128 && __ø< 256 ? (*
+	`__ùy³_touµ”_loc
+ ())[__c] : __c;
+
+200 
+	}
+}
+
+203 #ià
+__GNUC__
+ >ð2 && 
+defšed
+ 
+__OPTIMIZE__
+ && !defšed 
+__ýlu¥lus
+
+
+204 

+	#tÞow”
+(
+c
+è
+	`__tobody
+ (c, 
+tÞow”
+, *
+	`__ùy³_tÞow”_loc
+ (), (c))
+
+	)
+
+205 

+	#touµ”
+(
+c
+è
+	`__tobody
+ (c, 
+touµ”
+, *
+	`__ùy³_touµ”_loc
+ (), (c))
+
+	)
+
+208 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_MISC
+ || defšed 
+__USE_XOPEN
+
+
+209 

+	#i§scii
+(
+c
+è
+	`__i§scii
+ (c)
+
+	)
+
+210 

+	#tßscii
+(
+c
+è
+	`__tßscii
+ (c)
+
+	)
+
+212 

+	#_tÞow”
+(
+c
+è((è(*
+	`__ùy³_tÞow”_loc
+ ())[(è(c)])
+
+	)
+
+213 

+	#_touµ”
+(
+c
+è((è(*
+	`__ùy³_touµ”_loc
+ ())[(è(c)])
+
+	)
+
+219 #ifdeà
+__USE_XOPEN2K8
+
+
+233 
+	~<xloÿË.h
+>
+
+237 

+	#__isùy³_l
+(
+c
+, 
+ty³
+, 
+loÿË
+) \
+
+238 ((
+loÿË
+)->
+__ùy³_b
+[(è(
+c
+)] & (è
+ty³
+)
+
+	)
+
+240 

+	#__exùy³_l
+(
+Çme
+) \
+
+241 

+	`Çme
+ (, 
+__loÿË_t
+è
+__THROW
+
+
+	)
+
+247 
+__exùy³_l
+ (
+i§Êum_l
+);
+
+248 
+__exùy³_l
+ (
+i§Íha_l
+);
+
+249 
+__exùy³_l
+ (
+isúŒl_l
+);
+
+250 
+__exùy³_l
+ (
+isdig™_l
+);
+
+251 
+__exùy³_l
+ (
+i¦ow”_l
+);
+
+252 
+__exùy³_l
+ (
+isg¿ph_l
+);
+
+253 
+__exùy³_l
+ (
+i¥ršt_l
+);
+
+254 
+__exùy³_l
+ (
+i¥unù_l
+);
+
+255 
+__exùy³_l
+ (
+is¥aû_l
+);
+
+256 
+__exùy³_l
+ (
+isuµ”_l
+);
+
+257 
+__exùy³_l
+ (
+isxdig™_l
+);
+
+259 
+__exùy³_l
+ (
+isbÏnk_l
+);
+
+263 

+	$__tÞow”_l
+ (
+__c
+, 
+__loÿË_t
+ 
+__l
+è
+__THROW
+;
+
+264 

+	$tÞow”_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 && 
+defšed
+ 
+__OPTIMIZE__
+ && !defšed 
+__ýlu¥lus
+
+
+271 

+	#__tÞow”_l
+(
+c
+, 
+loÿË
+) \
+
+272 
+	`__tobody
+ (
+c
+, 
+__tÞow”_l
+, (
+loÿË
+)->
+__ùy³_tÞow”
+, (c,†oÿË))
+
+	)
+
+273 

+	#__touµ”_l
+(
+c
+, 
+loÿË
+) \
+
+274 
+	`__tobody
+ (
+c
+, 
+__touµ”_l
+, (
+loÿË
+)->
+__ùy³_touµ”
+, (c,†oÿË))
+
+	)
+
+275 

+	#tÞow”_l
+(
+c
+, 
+loÿË
+è
+	`__tÞow”_l
+ ((c), (loÿË))
+
+	)
+
+276 

+	#touµ”_l
+(
+c
+, 
+loÿË
+è
+	`__touµ”_l
+ ((c), (loÿË))
+
+	)
+
+280 #iâdeà
+__NO_CTYPE
+
+
+281 

+	#__i§Êum_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_IS®num
+, (l))
+
+	)
+
+282 

+	#__i§Íha_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_IS®pha
+, (l))
+
+	)
+
+283 

+	#__isúŒl_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISúŒl
+, (l))
+
+	)
+
+284 

+	#__isdig™_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISdig™
+, (l))
+
+	)
+
+285 

+	#__i¦ow”_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISlow”
+, (l))
+
+	)
+
+286 

+	#__isg¿ph_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISg¿ph
+, (l))
+
+	)
+
+287 

+	#__i¥ršt_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_IS´št
+, (l))
+
+	)
+
+288 

+	#__i¥unù_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISpunù
+, (l))
+
+	)
+
+289 

+	#__is¥aû_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_IS¥aû
+, (l))
+
+	)
+
+290 

+	#__isuµ”_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISuµ”
+, (l))
+
+	)
+
+291 

+	#__isxdig™_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISxdig™
+, (l))
+
+	)
+
+293 

+	#__isbÏnk_l
+(
+c
+,
+l
+è
+	`__isùy³_l
+((c), 
+_ISbÏnk
+, (l))
+
+	)
+
+295 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_MISC
+
+
+296 

+	#__i§scii_l
+(
+c
+,
+l
+è(Ö), 
+	`__i§scii
+ (c))
+
+	)
+
+297 

+	#__tßscii_l
+(
+c
+,
+l
+è(Ö), 
+	`__tßscii
+ (c))
+
+	)
+
+300 

+	#i§Êum_l
+(
+c
+,
+l
+è
+	`__i§Êum_l
+ ((c), (l))
+
+	)
+
+301 

+	#i§Íha_l
+(
+c
+,
+l
+è
+	`__i§Íha_l
+ ((c), (l))
+
+	)
+
+302 

+	#isúŒl_l
+(
+c
+,
+l
+è
+	`__isúŒl_l
+ ((c), (l))
+
+	)
+
+303 

+	#isdig™_l
+(
+c
+,
+l
+è
+	`__isdig™_l
+ ((c), (l))
+
+	)
+
+304 

+	#i¦ow”_l
+(
+c
+,
+l
+è
+	`__i¦ow”_l
+ ((c), (l))
+
+	)
+
+305 

+	#isg¿ph_l
+(
+c
+,
+l
+è
+	`__isg¿ph_l
+ ((c), (l))
+
+	)
+
+306 

+	#i¥ršt_l
+(
+c
+,
+l
+è
+	`__i¥ršt_l
+ ((c), (l))
+
+	)
+
+307 

+	#i¥unù_l
+(
+c
+,
+l
+è
+	`__i¥unù_l
+ ((c), (l))
+
+	)
+
+308 

+	#is¥aû_l
+(
+c
+,
+l
+è
+	`__is¥aû_l
+ ((c), (l))
+
+	)
+
+309 

+	#isuµ”_l
+(
+c
+,
+l
+è
+	`__isuµ”_l
+ ((c), (l))
+
+	)
+
+310 

+	#isxdig™_l
+(
+c
+,
+l
+è
+	`__isxdig™_l
+ ((c), (l))
+
+	)
+
+312 

+	#isbÏnk_l
+(
+c
+,
+l
+è
+	`__isbÏnk_l
+ ((c), (l))
+
+	)
+
+314 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_MISC
+
+
+315 

+	#i§scii_l
+(
+c
+,
+l
+è
+	`__i§scii_l
+ ((c), (l))
+
+	)
+
+316 

+	#tßscii_l
+(
+c
+,
+l
+è
+	`__tßscii_l
+ ((c), (l))
+
+	)
+
+323 
+__END_DECLS
+
+
+	@/usr/include/gnu/stubs.h
+
+4 
+	~<b™s/wÜdsize.h
+>
+
+6 #ià
+__WORDSIZE
+ == 32
+
+7 
+	~<gnu/¡ubs-32.h
+>
+
+8 #–ià
+__WORDSIZE
+ == 64
+
+9 
+	~<gnu/¡ubs-64.h
+>
+
+	@/usr/include/sys/cdefs.h
+
+20 #iâdef 
+_SYS_CDEFS_H
+
+
+21 

+	#_SYS_CDEFS_H
+ 1
+
+	)
+
+24 #iâdeà
+_FEATURES_H
+
+
+25 
+	~<ã©u»s.h
+>
+
+31 #ià
+defšed
+ 
+__GNUC__
+ && !defšed 
+__STDC__
+
+
+36 #undeà
+__P
+
+
+37 #undeà
+__PMT
+
+
+39 #ifdeà
+__GNUC__
+
+
+46 #ià!
+defšed
+ 
+__ýlu¥lus
+ && 
+__GNUC_PREREQ
+ (3, 3)
+
+47 

+	#__THROW
+ 
+	`__©Œibu‹__
+ ((
+__nÙhrow__
+))
+
+	)
+
+48 

+	#__NTH
+(
+fù
+è
+	`__©Œibu‹__
+ ((
+__nÙhrow__
+)è
+	)
+fct
+
+50 #ià
+defšed
+ 
+__ýlu¥lus
+ && 
+__GNUC_PREREQ
+ (2,8)
+
+51 

+	#__THROW
+ 
+	`throw
+ ()
+
+	)
+
+52 

+	#__NTH
+(
+fù
+èfù 
+	`throw
+ ()
+
+	)
+
+54 

+	#__THROW
+
+
+	)
+
+55 

+	#__NTH
+(
+fù
+è
+	)
+fct
+
+61 

+	#__šlše
+
+
+	)
+
+63 

+	#__THROW
+
+
+	)
+
+64 

+	#__NTH
+(
+fù
+è
+	)
+fct
+
+66 

+	#__cÚ¡
+ cÚ¡
+
+	)
+
+67 

+	#__sigÃd
+ sigÃd
+
+	)
+
+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 

+	#__lÚg_doubË_t
+ 
+
+	)
+
+89 #ifdef 
+__ýlu¥lus
+
+
+90 

+	#__BEGIN_DECLS
+ 
"C" {
+
+	)
+
+91 

+	#__END_DECLS
+ }
+
+	)
+
+93 

+	#__BEGIN_DECLS
+
+
+	)
+
+94 

+	#__END_DECLS
+
+
+	)
+
+103 #ià
+defšed
+ 
+__ýlu¥lus
+ && defšed 
+_GLIBCPP_USE_NAMESPACES
+
+
+104 

+	#__BEGIN_NAMESPACE_STD
+ 
+Çme¥aû
+ 
+¡d
+ {
+
+	)
+
+105 

+	#__END_NAMESPACE_STD
+ }
+
+	)
+
+106 

+	#__USING_NAMESPACE_STD
+(
+Çme
+è
+usšg
+ 
+¡d
+::Çme;
+
+	)
+
+107 

+	#__BEGIN_NAMESPACE_C99
+ 
+Çme¥aû
+ 
+__c99
+ {
+
+	)
+
+108 

+	#__END_NAMESPACE_C99
+ }
+
+	)
+
+109 

+	#__USING_NAMESPACE_C99
+(
+Çme
+è
+usšg
+ 
+__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 #iâdeà
+__BOUNDED_POINTERS__
+
+
+125 

+	#__bounded
+
+
+	)
+
+126 

+	#__unbounded
+
+
+	)
+
+127 

+	#__±rv®ue
+
+
+	)
+
+132 

+	#__bos
+(
+±r
+è
+	`__bužtš_objeù_size
+ (±r, 
+__USE_FORTIFY_LEVEL
+ > 1)
+
+	)
+
+133 

+	#__bos0
+(
+±r
+è
+	`__bužtš_objeù_size
+ (±r, 0)
+
+	)
+
+135 #ià
+__GNUC_PREREQ
+ (4,3)
+
+136 

+	#__w¬ndeþ
+(
+Çme
+, 
+msg
+) \
+
+137 

+	`Çme
+ (è
+	`__©Œibu‹__
+((
+	`__w¬nšg__
+ (
+msg
+)))
+
+	)
+
+138 

+	#__w¬Ç‰r
+(
+msg
+è
+	`__©Œibu‹__
+((
+	`__w¬nšg__
+ (msg)))
+
+	)
+
+139 

+	#__”rÜdeþ
+(
+Çme
+, 
+msg
+) \
+
+140 

+	`Çme
+ (è
+	`__©Œibu‹__
+((
+	`__”rÜ__
+ (
+msg
+)))
+
+	)
+
+142 

+	#__w¬ndeþ
+(
+Çme
+, 
+msg
+è

+	`Çme
+ ()
+
+	)
+
+143 

+	#__w¬Ç‰r
+(
+msg
+)
+
+	)
+
+144 

+	#__”rÜdeþ
+(
+Çme
+, 
+msg
+è

+	`Çme
+ ()
+
+	)
+
+148 #ià
+__GNUC_PREREQ
+ (2,97)
+
+150 

+	#__æex¬r
+ []
+
+	)
+
+152 #ifdeà
+__GNUC__
+
+
+153 

+	#__æex¬r
+ [0]
+
+	)
+
+155 #ià
+defšed
+ 
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L
+
+156 

+	#__æex¬r
+ []
+
+	)
+
+159 

+	#__æex¬r
+ [1]
+
+	)
+
+175 #ià
+defšed
+ 
+__GNUC__
+ && __GNUC__ >= 2
+
+177 

+	#__REDIRECT
+(
+Çme
+, 
+´Ùo
+, 
+®Ÿs
+èÇm�´ÙØ
+	`__asm__
+ (
+	`__ASMNAME
+ (#®Ÿs))
+
+	)
+
+178 #ifdeà
+__ýlu¥lus
+
+
+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__
+, cÇme)
+
+	)
+
+186 

+	#__ASMNAME2
+(
+´efix
+, 
+úame
+è
+	`__STRING
+ (´efixè
+	)
+cname
+
+199 #ià!
+defšed
+ 
+__GNUC__
+ || __GNUC__ < 2
+
+200 

+	#__©Œibu‹__
+(
+xyz
+è
+
+	)
+
+206 #ià
+__GNUC_PREREQ
+ (2,96)
+
+207 

+	#__©Œibu‹_m®loc__
+ 
+	`__©Œibu‹__
+ ((
+__m®loc__
+))
+
+	)
+
+209 

+	#__©Œibu‹_m®loc__
+
+
+	)
+
+215 #ià
+__GNUC_PREREQ
+ (2,96)
+
+216 

+	#__©Œibu‹_pu»__
+ 
+	`__©Œibu‹__
+ ((
+__pu»__
+))
+
+	)
+
+218 

+	#__©Œibu‹_pu»__
+
+
+	)
+
+224 #ià
+__GNUC_PREREQ
+ (3,1)
+
+225 

+	#__©Œibu‹_u£d__
+ 
+	`__©Œibu‹__
+ ((
+__u£d__
+))
+
+	)
+
+226 

+	#__©Œibu‹_nošlše__
+ 
+	`__©Œibu‹__
+ ((
+__nošlše__
+))
+
+	)
+
+228 

+	#__©Œibu‹_u£d__
+ 
+	`__©Œibu‹__
+ ((
+__unu£d__
+))
+
+	)
+
+229 

+	#__©Œibu‹_nošlše__
+
+
+	)
+
+233 #ià
+__GNUC_PREREQ
+ (3,2)
+
+234 

+	#__©Œibu‹_d•»ÿ‹d__
+ 
+	`__©Œibu‹__
+ ((
+__d•»ÿ‹d__
+))
+
+	)
+
+236 

+	#__©Œibu‹_d•»ÿ‹d__
+
+
+	)
+
+245 #ià
+__GNUC_PREREQ
+ (2,8)
+
+246 

+	#__©Œibu‹_fÜm©_¬g__
+(
+x
+è
+	`__©Œibu‹__
+ ((
+	`__fÜm©_¬g__
+ (x)))
+
+	)
+
+248 

+	#__©Œibu‹_fÜm©_¬g__
+(
+x
+è
+
+	)
+
+255 #ià
+__GNUC_PREREQ
+ (2,97)
+
+256 

+	#__©Œibu‹_fÜm©_¡rfmÚ__
+(
+a
+,
+b
+) \
+
+257 
+	`__©Œibu‹__
+ ((
+	`__fÜm©__
+ (
+__¡rfmÚ__
+, 
+a
+, 
+b
+)))
+
+	)
+
+259 

+	#__©Œibu‹_fÜm©_¡rfmÚ__
+(
+a
+,
+b
+è
+
+	)
+
+264 #ià
+__GNUC_PREREQ
+ (3,3)
+
+265 

+	#__nÚnuÎ
+(
+·¿ms
+è
+	`__©Œibu‹__
+ ((
+__nÚnuÎ__
+…¬ams))
+
+	)
+
+267 

+	#__nÚnuÎ
+(
+·¿ms
+)
+
+	)
+
+272 #ià
+__GNUC_PREREQ
+ (3,4)
+
+273 

+	#__©Œibu‹_w¬n_unu£d_»suÉ__
+ \
+
+274 
+	`__©Œibu‹__
+ ((
+__w¬n_unu£d_»suÉ__
+))
+
+	)
+
+275 #ià
+__USE_FORTIFY_LEVEL
+ > 0
+
+276 

+	#__wur
+ 
+__©Œibu‹_w¬n_unu£d_»suÉ__
+
+
+	)
+
+279 

+	#__©Œibu‹_w¬n_unu£d_»suÉ__
+
+
+	)
+
+281 #iâdeà
+__wur
+
+
+282 

+	#__wur
+
+
+	)
+
+286 #ià
+__GNUC_PREREQ
+ (3,2)
+
+287 

+	#__®ways_šlše
+ 
+__šlše
+ 
+	`__©Œibu‹__
+ ((
+__®ways_šlše__
+))
+
+	)
+
+289 

+	#__®ways_šlše
+ 
+__šlše
+
+
+	)
+
+294 #ià!
+defšed
+ 
+__ýlu¥lus
+ || 
+__GNUC_PREREQ
+ (4,3)
+
+295 #ià
+defšed
+ 
+__GNUC_STDC_INLINE__
+ || defšed 
+__ýlu¥lus
+
+
+296 

+	#__ex‹º_šlše
+ 

+__šlše
+ 
+	`__©Œibu‹__
+ ((
+__gnu_šlše__
+))
+
+	)
+
+297 #ià
+__GNUC_PREREQ
+ (4,3)
+
+298 

+	#__ex‹º_®ways_šlše
+ \
+
+299 

+__®ways_šlše
+ 
+	`__©Œibu‹__
+ ((
+__gnu_šlše__
+, 
+__¬tificŸl__
+))
+
+	)
+
+301 

+	#__ex‹º_®ways_šlše
+ \
+
+302 

+__®ways_šlše
+ 
+	`__©Œibu‹__
+ ((
+__gnu_šlše__
+))
+
+	)
+
+305 

+	#__ex‹º_šlše
+ 

+__šlše
+
+
+	)
+
+306 #ià
+__GNUC_PREREQ
+ (4,3)
+
+307 

+	#__ex‹º_®ways_šlše
+ \
+
+308 

+__®ways_šlše
+ 
+	`__©Œibu‹__
+ ((
+__¬tificŸl__
+))
+
+	)
+
+310 

+	#__ex‹º_®ways_šlše
+ 

+__®ways_šlše
+
+
+	)
+
+317 #ià
+__GNUC_PREREQ
+ (4,3)
+
+318 

+	#__va_¬g_·ck
+(è
+	`__bužtš_va_¬g_·ck
+ ()
+
+	)
+
+319 

+	#__va_¬g_·ck_Ën
+(è
+	`__bužtš_va_¬g_·ck_Ën
+ ()
+
+	)
+
+326 #ià!
+__GNUC_PREREQ
+ (2,8)
+
+327 

+	#__ex‹nsiÚ__
+
+
+	)
+
+331 #ià!
+__GNUC_PREREQ
+ (2,92)
+
+332 

+	#__»¡riù
+
+
+	)
+
+338 #ià
+__GNUC_PREREQ
+ (3,1è&& !
+defšed
+ 
+__GNUG__
+
+
+339 

+	#__»¡riù_¬r
+ 
+__»¡riù
+
+
+	)
+
+341 #ifdeà
+__GNUC__
+
+
+342 

+	#__»¡riù_¬r
+
+
+	)
+
+344 #ià
+defšed
+ 
+__STDC_VERSION__
+ && __STDC_VERSION__ >= 199901L
+
+345 

+	#__»¡riù_¬r
+ 
+»¡riù
+
+
+	)
+
+348 

+	#__»¡riù_¬r
+
+
+	)
+
+353 
+	~<b™s/wÜdsize.h
+>
+
+355 #ià
+defšed
+ 
+__LONG_DOUBLE_MATH_OPTIONAL
+ && defšed 
+__NO_LONG_DOUBLE_MATH
+
+
+356 

+	#__LDBL_COMPAT
+ 1
+
+	)
+
+357 #ifdeà
+__REDIRECT
+
+
+358 

+	#__LDBL_REDIR1
+(
+Çme
+, 
+´Ùo
+, 
+®Ÿs
+è
+	`__REDIRECT
+ (Çme,…rÙo,‡lŸs)
+
+	)
+
+359 

+	#__LDBL_REDIR
+(
+Çme
+, 
+´Ùo
+) \
+
+360 
+	`__LDBL_REDIR1
+ (
+Çme
+, 
+´Ùo
+, 
+__Ædbl_
+##Çme)
+
+	)
+
+361 

+	#__LDBL_REDIR1_NTH
+(
+Çme
+, 
+´Ùo
+, 
+®Ÿs
+è
+	`__REDIRECT_NTH
+ (Çme,…rÙo,‡lŸs)
+
+	)
+
+362 

+	#__LDBL_REDIR_NTH
+(
+Çme
+, 
+´Ùo
+) \
+
+363 
+	`__LDBL_REDIR1_NTH
+ (
+Çme
+, 
+´Ùo
+, 
+__Ædbl_
+##Çme)
+
+	)
+
+364 

+	#__LDBL_REDIR1_DECL
+(
+Çme
+, 
+®Ÿs
+) \
+
+365 

+	`__ty³of
+ (
+Çme
+èÇm�
+	`__asm
+ (
+	`__ASMNAME
+ (#®Ÿs));
+
+	)
+
+366 

+	#__LDBL_REDIR_DECL
+(
+Çme
+) \
+
+367 

+	`__ty³of
+ (
+Ç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à!
+defšed
+ 
+__LDBL_COMPAT
+ || !defšed 
+__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,…rÙo,‡lŸs)
+
+	)
+
+382 

+	#__REDIRECT_NTH_LDBL
+(
+Çme
+, 
+´Ùo
+, 
+®Ÿs
+) \
+
+383 
+	`__REDIRECT_NTH
+ (
+Çme
+, 
+´Ùo
+, 
+®Ÿs
+)
+
+	)
+
+	@/usr/include/bits/libc-lock.h
+
+20 #iâdeà
+_BITS_LIBC_LOCK_H
+
+
+21 

+	#_BITS_LIBC_LOCK_H
+ 1
+
+	)
+
+23 
+	~<±h»ad.h
+>
+
+24 

+	#__Ãed_NULL
+
+
+	)
+
+25 
+	~<¡ddef.h
+>
+
+34 #ifdeà
+_LIBC
+
+
+35 
+	~<lowËv–lock.h
+>
+
+36 
+	~<Žs.h
+>
+
+37 
+	~<±h»ad-funùiÚs.h
+>
+
+38 
+	~<Ӽo.h
+>
+
+39 
+	~<gnu/ÝtiÚ-groups.h
+>
+
+43 #ià
+defšed
+ 
+_LIBC
+ || defšed 
+_IO_MTSAFE_IO
+
+
+44 #ià(
+defšed
+ 
+NOT_IN_libc
+ && !defšed 
+IS_IN_lib±h»ad
+è|| !defšed 
+_LIBC
+
+
+45 
+±h»ad_mu‹x_t
+ 
+	t__libc_lock_t
+;
+
+46 ¡ruù { 
+±h»ad_mu‹x_t
+ 
+	mmu‹x
+; } 
+	t__libc_lock_»cursive_t
+;
+
+48 
+	t__libc_lock_t
+;
+
+49 ¡ruù { 
+	mlock
+; 
+	mút
+; *
+	mowÃr
+; } 
+	t__libc_lock_»cursive_t
+;
+
+51 ¡ruù { 
+±h»ad_mu‹x_t
+ 
+	mmu‹x
+; } 
+	t__¹ld_lock_»cursive_t
+;
+
+52 #ifdeà
+__USE_UNIX98
+
+
+53 
+±h»ad_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 
+±h»ad_key_t
+ 
+	t__libc_key_t
+;
+
+73 

+	#__libc_lock_defše
+(
+CLASS
+,
+NAME
+) \
+
+74 
+CLASS
+ 
+__libc_lock_t
+ 
+NAME
+;
+
+	)
+
+75 

+	#__libc_rwlock_defše
+(
+CLASS
+,
+NAME
+) \
+
+76 
+CLASS
+ 
+__libc_rwlock_t
+ 
+NAME
+;
+
+	)
+
+77 

+	#__libc_lock_defše_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+78 
+CLASS
+ 
+__libc_lock_»cursive_t
+ 
+NAME
+;
+
+	)
+
+79 

+	#__¹ld_lock_defše_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+80 
+CLASS
+ 
+__¹ld_lock_»cursive_t
+ 
+NAME
+;
+
+	)
+
+91 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+92 #ià
+LLL_LOCK_INITIALIZER
+ == 0
+
+93 

+	#__libc_lock_defše_š™Ÿlized
+(
+CLASS
+,
+NAME
+) \
+
+94 
+CLASS
+ 
+__libc_lock_t
+ 
+NAME
+;
+
+	)
+
+96 

+	#__libc_lock_defše_š™Ÿlized
+(
+CLASS
+,
+NAME
+) \
+
+97 
+CLASS
+ 
+__libc_lock_t
+ 
+NAME
+ = 
+LLL_LOCK_INITIALIZER
+;
+
+	)
+
+100 #ià
+__LT_SPINLOCK_INIT
+ == 0
+
+101 

+	#__libc_lock_defše_š™Ÿlized
+(
+CLASS
+,
+NAME
+) \
+
+102 
+CLASS
+ 
+__libc_lock_t
+ 
+NAME
+;
+
+	)
+
+104 

+	#__libc_lock_defše_š™Ÿlized
+(
+CLASS
+,
+NAME
+) \
+
+105 
+CLASS
+ 
+__libc_lock_t
+ 
+NAME
+ = 
+PTHREAD_MUTEX_INITIALIZER
+;
+
+	)
+
+109 

+	#__libc_rwlock_defše_š™Ÿlized
+(
+CLASS
+,
+NAME
+) \
+
+110 
+CLASS
+ 
+__libc_rwlock_t
+ 
+NAME
+ = 
+PTHREAD_RWLOCK_INITIALIZER
+;
+
+	)
+
+114 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+115 #ià
+LLL_LOCK_INITIALIZER
+ == 0
+
+116 

+	#__libc_lock_defše_š™Ÿlized_»cursive
+(
+CLASS
+,
+NAME
+) \
+
+117 
+CLASS
+ 
+__libc_lock_»cursive_t
+ 
+NAME
+;
+
+	)
+
+119 

+	#__libc_lock_defše_š™Ÿ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_defše_š™Ÿ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_defše_š™Ÿ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 (
+	`__ex‹nsiÚ__
+ ({ 
+	`__ty³of
+ (
+FUNC
+è*
+_â
+ = (FUNC); \
+
+147 
+_â
+ !ð
+NULL
+ ? (*_âè
+ARGS
+ : 
+ELSE
+; }))
+
+	)
+
+149 

+	#__libc_maybe_ÿÎ
+(
+FUNC
+, 
+ARGS
+, 
+ELSE
+) \
+
+150 (
+FUNC
+ !ð
+NULL
+ ? FUNC 
+ARGS
+ : 
+ELSE
+)
+
+	)
+
+154 #ià
+defšed
+ 
+SHARED
+ && !defšed 
+NOT_IN_libc
+
+
+155 

+	#PTFAVAIL
+(
+NAME
+è
+__libc_±h»ad_funùiÚs_š™
+
+
+	)
+
+156 

+	#__libc_±f_ÿÎ
+(
+FUNC
+, 
+ARGS
+, 
+ELSE
+) \
+
+157 (
+__libc_±h»ad_funùiÚs_š™
+ ? 
+	`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à
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+172 

+	#__libc_lock_š™
+(
+NAME
+è((NAMEèð
+LLL_LOCK_INITIALIZER
+, 0)
+
+	)
+
+174 

+	#__libc_lock_š™
+(
+NAME
+) \
+
+175 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_š™
+, (&(
+NAME
+), 
+NULL
+), 0)
+
+	)
+
+177 #ià
+defšed
+ 
+SHARED
+ && !defšed 
+NOT_IN_libc
+
+
+180 

+	#__libc_rwlock_š™
+(
+NAME
+) \
+
+181 (
+	`__bužtš_mem£t
+ (&(
+NAME
+), '\0',  (NAME)), 0)
+
+	)
+
+183 

+	#__libc_rwlock_š™
+(
+NAME
+) \
+
+184 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_š™
+, (&(
+NAME
+), 
+NULL
+), 0)
+
+	)
+
+188 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+189 

+	#__libc_lock_š™_»cursive
+(
+NAME
+) \
+
+190 ((
+NAME
+èð(
+__libc_lock_»cursive_t
+è
+_LIBC_LOCK_RECURSIVE_INITIALIZER
+, 0)
+
+	)
+
+192 

+	#__libc_lock_š™_»cursive
+(
+NAME
+) \
+
+194 ià(
+__±h»ad_mu‹x_š™
+ !ð
+NULL
+) \
+
+196 
+±h»ad_mu‹x©Œ_t
+ 
+__©Œ
+; \
+
+197 
+	`__±h»ad_mu‹x©Œ_š™
+ (&
+__©Œ
+); \
+
+198 
+	`__±h»ad_mu‹x©Œ_£‰y³
+ (&
+__©Œ
+, 
+PTHREAD_MUTEX_RECURSIVE_NP
+); \
+
+199 
+	`__±h»ad_mu‹x_š™
+ (&(
+NAME
+).
+mu‹x
+, &
+__©Œ
+); \
+
+200 
+	`__±h»ad_mu‹x©Œ_de¡roy
+ (&
+__©Œ
+); \
+
+202 } 0)
+
+	)
+
+205 

+	#__¹ld_lock_š™_»cursive
+(
+NAME
+) \
+
+207 ià(
+__±h»ad_mu‹x_š™
+ !ð
+NULL
+) \
+
+209 
+±h»ad_mu‹x©Œ_t
+ 
+__©Œ
+; \
+
+210 
+	`__±h»ad_mu‹x©Œ_š™
+ (&
+__©Œ
+); \
+
+211 
+	`__±h»ad_mu‹x©Œ_£‰y³
+ (&
+__©Œ
+, 
+PTHREAD_MUTEX_RECURSIVE_NP
+); \
+
+212 
+	`__±h»ad_mu‹x_š™
+ (&(
+NAME
+).
+mu‹x
+, &
+__©Œ
+); \
+
+213 
+	`__±h»ad_mu‹x©Œ_de¡roy
+ (&
+__©Œ
+); \
+
+215 } 0)
+
+	)
+
+220 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+221 

+	#__libc_lock_fši
+(
+NAME
+è((è0)
+
+	)
+
+223 

+	#__libc_lock_fši
+(
+NAME
+) \
+
+224 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_de¡roy
+, (&(
+NAME
+)), 0)
+
+	)
+
+226 #ià
+defšed
+ 
+SHARED
+ && !defšed 
+NOT_IN_libc
+
+
+227 

+	#__libc_rwlock_fši
+(
+NAME
+è((è0)
+
+	)
+
+229 

+	#__libc_rwlock_fši
+(
+NAME
+) \
+
+230 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_de¡roy
+, (&(
+NAME
+)), 0)
+
+	)
+
+234 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+235 

+	#__libc_lock_fši_»cursive
+(
+NAME
+è((è0)
+
+	)
+
+237 

+	#__libc_lock_fši_»cursive
+(
+NAME
+) \
+
+238 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_de¡roy
+, (&(
+NAME
+)), 0)
+
+	)
+
+242 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+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_ÿÎ
+ (
+__±h»ad_mu‹x_lock
+, (&(
+NAME
+)), 0)
+
+	)
+
+261 

+	#__libc_rwlock_rdlock
+(
+NAME
+) \
+
+262 
+	`__libc_±f_ÿÎ
+ (
+__±h»ad_rwlock_rdlock
+, (&(
+NAME
+)), 0)
+
+	)
+
+263 

+	#__libc_rwlock_w¾ock
+(
+NAME
+) \
+
+264 
+	`__libc_±f_ÿÎ
+ (
+__±h»ad_rwlock_w¾ock
+, (&(
+NAME
+)), 0)
+
+	)
+
+267 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+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
+).
+owÃr
+ !ð
+£lf
+) \
+
+281 
+	`Îl_lock
+ ((
+NAME
+).
+lock
+, 
+LLL_PRIVATE
+); \
+
+282 (
+NAME
+).
+owÃr
+ = 
+£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_ÿÎ
+ (
+__±h»ad_mu‹x_lock
+, (&(
+NAME
+).
+mu‹x
+), 0)
+
+	)
+
+296 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+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_ÿÎ
+ (
+__±h»ad_mu‹x_Œylock
+, (&(
+NAME
+)), 0)
+
+	)
+
+315 

+	#__libc_rwlock_Œyrdlock
+(
+NAME
+) \
+
+316 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_Œyrdlock
+, (&(
+NAME
+)), 0)
+
+	)
+
+317 

+	#__libc_rwlock_Œyw¾ock
+(
+NAME
+) \
+
+318 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_rwlock_Œyw¾ock
+, (&(
+NAME
+)), 0)
+
+	)
+
+321 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+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
+).
+owÃr
+ !ð
+£lf
+) \
+
+336 ià(
+	`Îl_Œylock
+ ((
+NAME
+).
+lock
+) == 0) \
+
+338 (
+NAME
+).
+owÃr
+ = 
+£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_ÿÎ
+ (
+__±h»ad_mu‹x_Œylock
+, (&(
+NAME
+)), 0)
+
+	)
+
+357 

+	#__¹ld_lock_Œylock_»cursive
+(
+NAME
+) \
+
+358 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_Œylock
+, (&(
+NAME
+).
+mu‹x
+), 0)
+
+	)
+
+361 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+362 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+366 

+__libc_lock_uÆock_â
+ (
+__libc_lock_t
+ *);
+
+367 
+libc_hidd’_´Ùo
+ (
+__libc_lock_uÆock_â
+);
+
+369 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+370 

+	#__libc_lock_uÆock
+(
+NAME
+) \
+
+371 
+	`Îl_uÆock
+ (
+NAME
+, 
+LLL_PRIVATE
+)
+
+	)
+
+373 

+	#__libc_lock_uÆock
+(
+NAME
+) \
+
+374 
+	`__libc_lock_uÆock_â
+ (&(
+NAME
+))
+
+	)
+
+377 

+	#__libc_lock_uÆock
+(
+NAME
+) \
+
+378 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_uÆock
+, (&(
+NAME
+)), 0)
+
+	)
+
+380 

+	#__libc_rwlock_uÆock
+(
+NAME
+) \
+
+381 
+	`__libc_±f_ÿÎ
+ (
+__±h»ad_rwlock_uÆock
+, (&(
+NAME
+)), 0)
+
+	)
+
+384 #ià
+defšed
+ 
+_LIBC
+ && (!defšed 
+NOT_IN_libc
+ || defšed 
+IS_IN_lib±h»ad
+)
+
+385 #ià
+__OPTION_EGLIBC_BIG_MACROS
+ != 1
+
+389 

+__libc_lock_uÆock_»cursive_â
+ (
+__libc_lock_»cursive_t
+ *);
+
+390 
+libc_hidd’_´Ùo
+ (
+__libc_lock_uÆock_»cursive_â
+);
+
+392 #ià
+__OPTION_EGLIBC_BIG_MACROS
+
+
+394 

+	#__libc_lock_uÆock_»cursive
+(
+NAME
+) \
+
+396 ià(--(
+NAME
+).
+út
+ == 0) \
+
+398 (
+NAME
+).
+owÃr
+ = 
+NULL
+; \
+
+399 
+	`Îl_uÆock
+ ((
+NAME
+).
+lock
+, 
+LLL_PRIVATE
+); \
+
+401 } 0)
+
+	)
+
+403 

+	#__libc_lock_uÆock_»cursive
+(
+NAME
+) \
+
+404 
+	`__libc_lock_uÆock_»cursive_â
+ (&(
+NAME
+))
+
+	)
+
+407 

+	#__libc_lock_uÆock_»cursive
+(
+NAME
+) \
+
+408 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_uÆock
+, (&(
+NAME
+)), 0)
+
+	)
+
+411 #ià
+defšed
+ 
+_LIBC
+ && defšed 
+SHARED
+
+
+412 

+	#__¹ld_lock_deçuÉ_lock_»cursive
+(
+lock
+) \
+
+413 ++((
+±h»ad_mu‹x_t
+ *)(
+lock
+))->
+__d©a
+.
+__couÁ
+;
+
+	)
+
+415 

+	#__¹ld_lock_deçuÉ_uÆock_»cursive
+(
+lock
+) \
+
+416 --((
+±h»ad_mu‹x_t
+ *)(
+lock
+))->
+__d©a
+.
+__couÁ
+;
+
+	)
+
+418 

+	#__¹ld_lock_lock_»cursive
+(
+NAME
+) \
+
+419 
+	`GL
+(
+dl_¹ld_lock_»cursive
+è(&(
+NAME
+).
+mu‹x
+)
+
+	)
+
+421 

+	#__¹ld_lock_uÆock_»cursive
+(
+NAME
+) \
+
+422 
+	`GL
+(
+dl_¹ld_uÆock_»cursive
+è(&(
+NAME
+).
+mu‹x
+)
+
+	)
+
+424 

+	#__¹ld_lock_lock_»cursive
+(
+NAME
+) \
+
+425 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_lock
+, (&(
+NAME
+).
+mu‹x
+), 0)
+
+	)
+
+427 

+	#__¹ld_lock_uÆock_»cursive
+(
+NAME
+) \
+
+428 
+	`__libc_maybe_ÿÎ
+ (
+__±h»ad_mu‹x_uÆock
+, (&(
+NAME
+).
+mu‹x
+), 0)
+
+	)
+
+432 #ià
+PTHREAD_ONCE_INIT
+ == 0
+
+435 

+	#__libc_Úû_defše
+(
+CLASS
+, 
+NAME
+) \
+
+436 
+CLASS
+ 
+±h»ad_Úû_t
+ 
+NAME
+
+
+	)
+
+438 

+	#__libc_Úû_defše
+(
+CLASS
+, 
+NAME
+) \
+
+439 
+CLASS
+ 
+±h»ad_Úû_t
+ 
+NAME
+ = 
+PTHREAD_ONCE_INIT
+
+
+	)
+
+443 

+	#__libc_Úû
+(
+ONCE_CONTROL
+, 
+INIT_FUNCTION
+) \
+
+445 ià(
+	`PTFAVAIL
+ (
+__±h»ad_Úû
+)) \
+
+446 
+	`__libc_±f_ÿÎ_®ways
+ (
+__±h»ad_Úû
+, (&(
+ONCE_CONTROL
+), \
+
+447 
+INIT_FUNCTION
+)); \
+
+448 ià((
+ONCE_CONTROL
+è=ð
+PTHREAD_ONCE_INIT
+) { \
+
+449 
+	`INIT_FUNCTION
+ (); \
+
+450 (
+ONCE_CONTROL
+) |= 2; \
+
+452 } 0)
+
+	)
+
+459 

+_±h»ad_þ—nup_push
+ (
+_±h»ad_þ—nup_bufãr
+ *
+bufãr
+,
+
+460 (*
+routše
+è(*), *
+¬g
+);
+
+461 

+	`_±h»ad_þ—nup_pÝ
+ (
+_±h»ad_þ—nup_bufãr
+ *
+bufãr
+,
+
+462 
+execu‹
+);
+
+463 

+	`_±h»ad_þ—nup_push_deãr
+ (
+_±h»ad_þ—nup_bufãr
+ *
+bufãr
+,
+
+464 (*
+routše
+è(*), *
+¬g
+);
+
+465 

+	`_±h»ad_þ—nup_pÝ_»¡Üe
+ (
+_±h»ad_þ—nup_bufãr
+ *
+bufãr
+,
+
+466 
+execu‹
+);
+
+469 

+	#__libc_þ—nup_»giÚ_¡¬t
+(
+DOIT
+, 
+FCT
+, 
+ARG
+) \
+
+470 { 
+_±h»ad_þ—nup_bufãr
+ 
+_bufãr
+; \
+
+471 
+_avaž
+; \
+
+472 ià(
+DOIT
+) { \
+
+473 
+_avaž
+ = 
+	`PTFAVAIL
+ (
+_±h»ad_þ—nup_push_deãr
+); \
+
+474 ià(
+_avaž
+) { \
+
+475 
+	`__libc_±f_ÿÎ_®ways
+ (
+_±h»ad_þ—nup_push_deãr
+, (&
+_bufãr
+, 
+FCT
+, \
+
+476 
+ARG
+)); \
+
+478 
+_bufãr
+.
+__routše
+ = (
+FCT
+); \
+
+479 
+_bufãr
+.
+__¬g
+ = (
+ARG
+); \
+
+482 
+_avaž
+ = 0; \
+
+483 }
+
+	)
+
+486 

+	#__libc_þ—nup_»giÚ_’d
+(
+DOIT
+) \
+
+487 ià(
+_avaž
+) { \
+
+488 
+	`__libc_±f_ÿÎ_®ways
+ (
+_±h»ad_þ—nup_pÝ_»¡Üe
+, (&
+_bufãr
+, 
+DOIT
+));\
+
+489 } ià(
+DOIT
+) \
+
+490 
+_bufãr
+.
+	`__routše
+ (_bufãr.
+__¬g
+); \
+
+491 
+	}
+
+	)
+}
+
+494 

+	#__libc_þ—nup_’d
+(
+DOIT
+) \
+
+495 ià(
+_avaž
+) { \
+
+496 
+	`__libc_±f_ÿÎ_®ways
+ (
+_±h»ad_þ—nup_pÝ_»¡Üe
+, (&
+_bufãr
+, 
+DOIT
+));\
+
+497 } ià(
+DOIT
+) \
+
+498 
+_bufãr
+.
+	`__routše
+ (_bufãr.
+__¬g
+)
+
+	)
+
+502 
+__ex‹º_šlše
+ 
+
+503 
+	$__libc_þ—nup_routše
+ (
+__±h»ad_þ—nup_äame
+ *
+f
+)
+
+505 ià(
+f
+->
+__do_™
+)
+
+506 
+f
+->
+	`__ÿnûl_routše
+ (f->
+__ÿnûl_¬g
+);
+
+507 
+	}
+}
+
+509 

+	#__libc_þ—nup_push
+(
+fù
+, 
+¬g
+) \
+
+511 
+__±h»ad_þ—nup_äame
+ 
+__þäame
+ \
+
+512 
+	`__©Œibu‹__
+ ((
+	`__þ—nup__
+ (
+__libc_þ—nup_routše
+))) \
+
+513 ð{ .
+__ÿnûl_routše
+ = (
+fù
+), .
+__ÿnûl_¬g
+ = (
+¬g
+), \
+
+514 .
+__do_™
+ = 1 };
+
+	)
+
+516 

+	#__libc_þ—nup_pÝ
+(
+execu‹
+) \
+
+517 
+__þäame
+.
+__do_™
+ = (
+execu‹
+); \
+
+518 } 0)
+
+	)
+
+522 

+	#__libc_key_ü—‹
+(
+KEY
+, 
+DESTRUCTOR
+) \
+
+523 
+	`__libc_±f_ÿÎ
+ (
+__±h»ad_key_ü—‹
+, (
+KEY
+, 
+DESTRUCTOR
+), 1)
+
+	)
+
+526 

+	#__libc_g‘¥ecific
+(
+KEY
+) \
+
+527 
+	`__libc_±f_ÿÎ
+ (
+__±h»ad_g‘¥ecific
+, (
+KEY
+), 
+NULL
+)
+
+	)
+
+530 

+	#__libc_£t¥ecific
+(
+KEY
+, 
+VALUE
+) \
+
+531 
+	`__libc_±f_ÿÎ
+ (
+__±h»ad_£t¥ecific
+, (
+KEY
+, 
+VALUE
+), 0)
+
+	)
+
+537 

+	#__libc_©fÜk
+(
+PREPARE
+, 
+PARENT
+, 
+CHILD
+) \
+
+538 
+	`__»gi¡”_©fÜk
+ (
+PREPARE
+, 
+PARENT
+, 
+CHILD
+, 
+NULL
+)
+
+	)
+
+539 

+__»gi¡”_©fÜk
+ ((*
+__´•¬e
+) (),
+
+540 (*
+__·»Á
+) (),
+
+541 (*
+__chžd
+) (),
+
+542 *
+__dso_hªdË
+);
+
+547 

+	`__±h»ad_mu‹x_š™
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+,
+
+548 
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+__mu‹x_©Œ
+);
+
+550 

+	`__±h»ad_mu‹x_de¡roy
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+);
+
+552 

+	`__±h»ad_mu‹x_Œylock
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+);
+
+554 

+	`__±h»ad_mu‹x_lock
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+);
+
+556 

+	`__±h»ad_mu‹x_uÆock
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+);
+
+558 

+	`__±h»ad_mu‹x©Œ_š™
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+);
+
+560 

+	`__±h»ad_mu‹x©Œ_de¡roy
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+);
+
+562 

+	`__±h»ad_mu‹x©Œ_£‰y³
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+563 
+__kšd
+);
+
+565 #ifdeà
+__USE_UNIX98
+
+
+566 

+	`__±h»ad_rwlock_š™
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+,
+
+567 
+__cÚ¡
+ 
+±h»ad_rwlock©Œ_t
+ *
+__©Œ
+);
+
+569 

+	`__±h»ad_rwlock_de¡roy
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+571 

+	`__±h»ad_rwlock_rdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+573 

+	`__±h»ad_rwlock_Œyrdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+575 

+	`__±h»ad_rwlock_w¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+577 

+	`__±h»ad_rwlock_Œyw¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+579 

+	`__±h»ad_rwlock_uÆock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+);
+
+582 

+	`__±h»ad_key_ü—‹
+ (
+±h»ad_key_t
+ *
+__key
+,
+
+583 (*
+__de¡r_funùiÚ
+) (*));
+
+585 

+	`__±h»ad_£t¥ecific
+ (
+±h»ad_key_t
+ 
+__key
+,
+
+586 
+__cÚ¡
+ *
+__poš‹r
+);
+
+588 
*
+	`__±h»ad_g‘¥ecific
+ (
+±h»ad_key_t
+ 
+__key
+);
+
+590 

+	`__±h»ad_Úû
+ (
+±h»ad_Úû_t
+ *
+__Úû_cÚŒÞ
+,
+
+591 (*
+__š™_routše
+) ());
+
+593 

+	`__±h»ad_©fÜk
+ ((*
+__´•¬e
+) (),
+
+594 (*
+__·»Á
+) (),
+
+595 (*
+__chžd
+) ());
+
+601 #iâdeà
+__NO_WEAK_PTHREAD_ALIASES
+
+
+602 #ifdeà
+w—k_ex‹º
+
+
+603 #ià
+_LIBC
+
+
+604 
+	~<bp-sym.h
+>
+
+606 

+	#BP_SYM
+(
+sym
+è
+	)
+sym
+
+608 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x_š™
+))
+
+609 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x_de¡roy
+))
+
+610 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x_lock
+))
+
+611 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x_Œylock
+))
+
+612 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x_uÆock
+))
+
+613 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x©Œ_š™
+))
+
+614 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x©Œ_de¡roy
+))
+
+615 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_mu‹x©Œ_£‰y³
+))
+
+616 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_š™
+))
+
+617 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_de¡roy
+))
+
+618 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_rdlock
+))
+
+619 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_Œyrdlock
+))
+
+620 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_w¾ock
+))
+
+621 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_Œyw¾ock
+))
+
+622 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_rwlock_uÆock
+))
+
+623 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_key_ü—‹
+))
+
+624 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_£t¥ecific
+))
+
+625 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_g‘¥ecific
+))
+
+626 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+__±h»ad_Úû
+))
+
+627 
+	$w—k_ex‹º
+ (
+__±h»ad_š™Ÿlize
+)
+
+628 
+	$w—k_ex‹º
+ (
+__±h»ad_©fÜk
+)
+
+629 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+_±h»ad_þ—nup_push_deãr
+))
+
+630 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+_±h»ad_þ—nup_pÝ_»¡Üe
+))
+
+631 
+	`w—k_ex‹º
+ (
+	$BP_SYM
+ (
+±h»ad_£tÿnûl¡©e
+))
+
+633 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x_š™
+
+
+634 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x_de¡roy
+
+
+635 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x_lock
+
+
+636 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x_Œylock
+
+
+637 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x_uÆock
+
+
+638 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x©Œ_š™
+
+
+639 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x©Œ_de¡roy
+
+
+640 #´agm¨
+w—k
+ 
+__±h»ad_mu‹x©Œ_£‰y³
+
+
+641 #´agm¨
+w—k
+ 
+__±h»ad_rwlock_de¡roy
+
+
+642 #´agm¨
+w—k
+ 
+__±h»ad_rwlock_rdlock
+
+
+643 #´agm¨
+w—k
+ 
+__±h»ad_rwlock_Œyrdlock
+
+
+644 #´agm¨
+w—k
+ 
+__±h»ad_rwlock_w¾ock
+
+
+645 #´agm¨
+w—k
+ 
+__±h»ad_rwlock_Œyw¾ock
+
+
+646 #´agm¨
+w—k
+ 
+__±h»ad_rwlock_uÆock
+
+
+647 #´agm¨
+w—k
+ 
+__±h»ad_key_ü—‹
+
+
+648 #´agm¨
+w—k
+ 
+__±h»ad_£t¥ecific
+
+
+649 #´agm¨
+w—k
+ 
+__±h»ad_g‘¥ecific
+
+
+650 #´agm¨
+w—k
+ 
+__±h»ad_Úû
+
+
+651 #´agm¨
+w—k
+ 
+__±h»ad_š™Ÿlize
+
+
+652 #´agm¨
+w—k
+ 
+__±h»ad_©fÜk
+
+
+653 #´agm¨
+w—k
+ 
+_±h»ad_þ—nup_push_deãr
+
+
+654 #´agm¨
+w—k
+ 
+_±h»ad_þ—nup_pÝ_»¡Üe
+
+
+655 #´agm¨
+w—k
+ 
+±h»ad_£tÿnûl¡©e
+
+
+	@/usr/include/endian.h
+
+19 #iâdef 
+_ENDIAN_H
+
+
+20 

+	#_ENDIAN_H
+ 1
+
+	)
+
+22 
+	~<ã©u»s.h
+>
+
+32 

+	#__LITTLE_ENDIAN
+ 1234
+
+	)
+
+33 

+	#__BIG_ENDIAN
+ 4321
+
+	)
+
+34 

+	#__PDP_ENDIAN
+ 3412
+
+	)
+
+37 
+	~<b™s/’dŸn.h
+>
+
+41 #iâdeà
+__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 
+	~<b™s/by‹sw­.h
+>
+
+63 #ià
+__BYTE_ORDER
+ =ð
+__LITTLE_ENDIAN
+
+
+64 

+	#htobe16
+(
+x
+è
+	`__bsw­_16
+ (x)
+
+	)
+
+65 

+	#htÞe16
+(
+x
+è(x)
+
+	)
+
+66 

+	#be16toh
+(
+x
+è
+	`__bsw­_16
+ (x)
+
+	)
+
+67 

+	#Ë16toh
+(
+x
+è(x)
+
+	)
+
+69 

+	#htobe32
+(
+x
+è
+	`__bsw­_32
+ (x)
+
+	)
+
+70 

+	#htÞe32
+(
+x
+è(x)
+
+	)
+
+71 

+	#be32toh
+(
+x
+è
+	`__bsw­_32
+ (x)
+
+	)
+
+72 

+	#Ë32toh
+(
+x
+è(x)
+
+	)
+
+74 

+	#htobe64
+(
+x
+è
+	`__bsw­_64
+ (x)
+
+	)
+
+75 

+	#htÞe64
+(
+x
+è(x)
+
+	)
+
+76 

+	#be64toh
+(
+x
+è
+	`__bsw­_64
+ (x)
+
+	)
+
+77 

+	#Ë64toh
+(
+x
+è(x)
+
+	)
+
+79 

+	#htobe16
+(
+x
+è(x)
+
+	)
+
+80 

+	#htÞe16
+(
+x
+è
+	`__bsw­_16
+ (x)
+
+	)
+
+81 

+	#be16toh
+(
+x
+è(x)
+
+	)
+
+82 

+	#Ë16toh
+(
+x
+è
+	`__bsw­_16
+ (x)
+
+	)
+
+84 

+	#htobe32
+(
+x
+è(x)
+
+	)
+
+85 

+	#htÞe32
+(
+x
+è
+	`__bsw­_32
+ (x)
+
+	)
+
+86 

+	#be32toh
+(
+x
+è(x)
+
+	)
+
+87 

+	#Ë32toh
+(
+x
+è
+	`__bsw­_32
+ (x)
+
+	)
+
+89 

+	#htobe64
+(
+x
+è(x)
+
+	)
+
+90 

+	#htÞe64
+(
+x
+è
+	`__bsw­_64
+ (x)
+
+	)
+
+91 

+	#be64toh
+(
+x
+è(x)
+
+	)
+
+92 

+	#Ë64toh
+(
+x
+è
+	`__bsw­_64
+ (x)
+
+	)
+
+	@/usr/include/gconv.h
+
+23 #iâdeà
+_GCONV_H
+
+
+24 

+	#_GCONV_H
+ 1
+
+	)
+
+26 
+	~<ã©u»s.h
+>
+
+27 

+	#__Ãed_mb¡©e_t
+
+
+	)
+
+28 

+	#__Ãed_wšt_t
+
+
+	)
+
+29 
+	~<wch¬.h
+>
+
+30 

+	#__Ãed_size_t
+
+
+	)
+
+31 

+	#__Ãed_wch¬_t
+
+
+	)
+
+32 
+	~<¡ddef.h
+>
+
+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__gcÚv_¡•
+;
+
+65 
+	g__gcÚv_¡•_d©a
+;
+
+66 
+	g__gcÚv_lßded_objeù
+;
+
+67 
+	g__gcÚv_Œªs_d©a
+;
+
+71 (*
+	t__gcÚv_fù
+è(
+	t__gcÚv_¡•
+ *, 
+	t__gcÚv_¡•_d©a
+ *,
+
+72 
+	t__cÚ¡
+ **, __const *,
+
+73 **, 
+	tsize_t
+ *, , );
+
+76 
+	$wšt_t
+ (*
+	t__gcÚv_btowc_fù
+è(
+	t__gcÚv_¡•
+ *, );
+
+79 (*
+	t__gcÚv_š™_fù
+è(
+	t__gcÚv_¡•
+ *);
+
+80 (*
+	t__gcÚv_’d_fù
+è(
+	t__gcÚv_¡•
+ *);
+
+84 (*
+	t__gcÚv_Œªs_fù
+è(
+	t__gcÚv_¡•
+ *,
+
+85 
+	t__gcÚv_¡•_d©a
+ *, *,
+
+86 
+	t__cÚ¡
+ *,
+
+87 
+	t__cÚ¡
+ **,
+
+88 
+	t__cÚ¡
+ *, **,
+
+89 
+	tsize_t
+ *);
+
+92 (*
+	t__gcÚv_Œªs_cÚ‹xt_fù
+è(*, 
+	t__cÚ¡
+ *,
+
+93 
+	t__cÚ¡
+ *,
+
+97 (*
+	t__gcÚv_Œªs_qu”y_fù
+è(
+	t__cÚ¡
+ *, __const ***,
+
+98 
+	tsize_t
+ *);
+
+101 (*
+	t__gcÚv_Œªs_š™_fù
+) (**, const *);
+
+102 (*
+	t__gcÚv_Œªs_’d_fù
+) (*);
+
+104 
+	s__gcÚv_Œªs_d©a
+
+
+107 
+__gcÚv_Œªs_fù
+ 
+__Œªs_fù
+;
+
+108 
+__gcÚv_Œªs_cÚ‹xt_fù
+ 
+__Œªs_cÚ‹xt_fù
+;
+
+109 
+__gcÚv_Œªs_’d_fù
+ 
+__Œªs_’d_fù
+;
+
+110 *
+__d©a
+;
+
+111 
+__gcÚv_Œªs_d©a
+ *
+__Ãxt
+;
+
+116 
+	s__gcÚv_¡•
+
+
+118 
+__gcÚv_lßded_objeù
+ *
+__shlib_hªdË
+;
+
+119 
+__cÚ¡
+ *
+__modÇme
+;
+
+121 
+__couÁ”
+;
+
+123 *
+__äom_Çme
+;
+
+124 *
+__to_Çme
+;
+
+126 
+__gcÚv_fù
+ 
+__fù
+;
+
+127 
+__gcÚv_btowc_fù
+ 
+__btowc_fù
+;
+
+128 
+__gcÚv_š™_fù
+ 
+__š™_fù
+;
+
+129 
+__gcÚv_’d_fù
+ 
+__’d_fù
+;
+
+133 
+__mš_Ãeded_äom
+;
+
+134 
+__max_Ãeded_äom
+;
+
+135 
+__mš_Ãeded_to
+;
+
+136 
+__max_Ãeded_to
+;
+
+139 
+__¡©eful
+;
+
+141 *
+__d©a
+;
+
+146 
+	s__gcÚv_¡•_d©a
+
+
+148 *
+__outbuf
+;
+
+149 *
+__outbuãnd
+;
+
+153 
+__æags
+;
+
+157 
+__švoÿtiÚ_couÁ”
+;
+
+161 
+__š‹º®_u£
+;
+
+163 
+__mb¡©e_t
+ *
+__¡©•
+;
+
+164 
+__mb¡©e_t
+ 
+__¡©e
+;
+
+168 
+__gcÚv_Œªs_d©a
+ *
+__λs
+;
+
+173 
+	s__gcÚv_šfo
+
+
+175 
+size_t
+ 
+__n¡•s
+;
+
+176 
+__gcÚv_¡•
+ *
+__¡•s
+;
+
+177 
+__ex‹nsiÚ__
+ 
+__gcÚv_¡•_d©a
+ 
+__d©a
+ 
+__æex¬r
+;
+
+178 } *
+	t__gcÚv_t
+;
+
+	@/usr/include/gnu/stubs-32.h
+
+6 #ifdeà
+_LIBC
+
+
+7 #”rÜ 
+AµliÿtiÚs
+ 
+may
+ 
+nÙ
+ 
+defše
+ 
+the
+ 
+maüo
+ 
+_LIBC
+
+
+10 

+	#__¡ub___k”Ãl_co¦
+
+
+	)
+
+11 

+	#__¡ub___k”Ãl_sšl
+
+
+	)
+
+12 

+	#__¡ub___k”Ãl_�Æ
+
+
+	)
+
+13 

+	#__¡ub_chæags
+
+
+	)
+
+14 

+	#__¡ub_ç‰ach
+
+
+	)
+
+15 

+	#__¡ub_fchæags
+
+
+	)
+
+16 

+	#__¡ub_fd‘ach
+
+
+	)
+
+17 

+	#__¡ub_g‰y
+
+
+	)
+
+18 

+	#__¡ub_lchmod
+
+
+	)
+
+19 

+	#__¡ub_»voke
+
+
+	)
+
+20 

+	#__¡ub_£Žogš
+
+
+	)
+
+21 

+	#__¡ub_sig»tuº
+
+
+	)
+
+22 

+	#__¡ub_s¡k
+
+
+	)
+
+23 

+	#__¡ub_¡ty
+
+
+	)
+
+	@/usr/include/gnu/stubs-64.h
+
+6 #ifdeà
+_LIBC
+
+
+7 #”rÜ 
+AµliÿtiÚs
+ 
+may
+ 
+nÙ
+ 
+defše
+ 
+the
+ 
+maüo
+ 
+_LIBC
+
+
+10 

+	#__¡ub_bdæush
+
+
+	)
+
+11 

+	#__¡ub_chæags
+
+
+	)
+
+12 

+	#__¡ub_ç‰ach
+
+
+	)
+
+13 

+	#__¡ub_fchæags
+
+
+	)
+
+14 

+	#__¡ub_fd‘ach
+
+
+	)
+
+15 

+	#__¡ub_g‘msg
+
+
+	)
+
+16 

+	#__¡ub_g‰y
+
+
+	)
+
+17 

+	#__¡ub_lchmod
+
+
+	)
+
+18 

+	#__¡ub_putmsg
+
+
+	)
+
+19 

+	#__¡ub_»voke
+
+
+	)
+
+20 

+	#__¡ub_£Žogš
+
+
+	)
+
+21 

+	#__¡ub_sig»tuº
+
+
+	)
+
+22 

+	#__¡ub_s¡k
+
+
+	)
+
+23 

+	#__¡ub_¡ty
+
+
+	)
+
+	@/usr/include/wchar.h
+
+24 #iâdeà
+_WCHAR_H
+
+
+26 #ià!
+defšed
+ 
+__Ãed_mb¡©e_t
+ && !defšed 
+__Ãed_wšt_t
+
+
+27 

+	#_WCHAR_H
+ 1
+
+	)
+
+28 
+	~<ã©u»s.h
+>
+
+31 #ifdeà
+_WCHAR_H
+
+
+33 

+	#__Ãed___FILE
+
+
+	)
+
+34 #ià
+defšed
+ 
+__USE_UNIX98
+ || defšed 
+__USE_XOPEN2K
+
+
+35 

+	#__Ãed_FILE
+
+
+	)
+
+37 
+	~<¡dio.h
+>
+
+39 

+	#__Ãed___va_li¡
+
+
+	)
+
+40 
+	~<¡d¬g.h
+>
+
+42 
+	~<b™s/wch¬.h
+>
+
+45 

+	#__Ãed_size_t
+
+
+	)
+
+46 

+	#__Ãed_wch¬_t
+
+
+	)
+
+47 

+	#__Ãed_NULL
+
+
+	)
+
+49 #ià
+defšed
+ 
+_WCHAR_H
+ || defšed 
+__Ãed_wšt_t
+ || !defšed 
+__WINT_TYPE__
+
+
+50 #undeà
+__Ãed_wšt_t
+
+
+51 

+	#__Ãed_wšt_t
+
+
+	)
+
+52 
+	~<¡ddef.h
+>
+
+55 #ià
+defšed
+ 
+__ýlu¥lus
+ && 
+__GNUC_PREREQ
+ (4, 4)
+
+56 

+	#__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+	)
+
+61 #iâdeà
+_WINT_T
+
+
+66 

+	#_WINT_T
+
+
+	)
+
+67 
+	twšt_t
+;
+
+71 #ià
+defšed
+ 
+__ýlu¥lus
+ && defšed 
+_GLIBCPP_USE_NAMESPACES
+ \
+
+72 && 
+defšed
+ 
+__WINT_TYPE__
+
+
+73 
+__BEGIN_NAMESPACE_STD
+
+
+74 
+__WINT_TYPE__
+ 
+	twšt_t
+;
+
+75 
+	g__END_NAMESPACE_STD
+
+
+80 #ià(
+defšed
+ 
+_WCHAR_H
+ || defšed 
+__Ãed_mb¡©e_t
+è&& !defšed 
+__mb¡©e_t_defšed
+
+
+81 

+	#__mb¡©e_t_defšed
+ 1
+
+	)
+
+85 
+	m__couÁ
+;
+
+88 #ifdeà
+__WINT_TYPE__
+
+
+89 
+__WINT_TYPE__
+ 
+	m__wch
+;
+
+91 
+wšt_t
+ 
+	m__wch
+;
+
+93 
+	m__wchb
+[4];
+
+94 } 
+	m__v®ue
+;
+
+95 } 
+	t__mb¡©e_t
+;
+
+97 #undeà
+__Ãed_mb¡©e_t
+
+
+102 #ifdeà
+_WCHAR_H
+
+
+104 
+__BEGIN_NAMESPACE_C99
+
+
+106 
+__mb¡©e_t
+ 
+	tmb¡©e_t
+;
+
+107 
+	g__END_NAMESPACE_C99
+
+
+108 #ifdeà
+__USE_GNU
+
+
+109 
+	$__USING_NAMESPACE_C99
+(
+mb¡©e_t
+)
+
+112 #iâdeà
+WCHAR_MIN
+
+
+114 

+	#WCHAR_MIN
+ 
+__WCHAR_MIN
+
+
+	)
+
+115 

+	#WCHAR_MAX
+ 
+__WCHAR_MAX
+
+
+	)
+
+118 #iâdeà
+WEOF
+
+
+119 

+	#WEOF
+ (0xffffffffu)
+
+	)
+
+124 #ià
+defšed
+ 
+__USE_XOPEN
+ && !defšed 
+__USE_UNIX98
+
+
+125 
+	~<wùy³.h
+>
+
+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
+ *
+	$wcsýy
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+145 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+è
+__THROW
+;
+
+147 

+wch¬_t
+ *
+	$wc¢ýy
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+148 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__n
+)
+
+149 
+__THROW
+;
+
+152 

+wch¬_t
+ *
+	$wcsÿt
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+153 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+è
+__THROW
+;
+
+155 

+wch¬_t
+ *
+	$wc¢ÿt
+ (
+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 

+	$wc¢cmp
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+, 
+size_t
+ 
+__n
+)
+
+164 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+165 
+__END_NAMESPACE_STD
+
+
+167 #ifdeà
+__USE_XOPEN2K8
+
+
+169 

+	$wcsÿ£cmp
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+è
+__THROW
+;
+
+172 

+	$wc¢ÿ£cmp
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+,
+
+173 
+size_t
+ 
+__n
+è
+__THROW
+;
+
+177 
+	~<xloÿË.h
+>
+
+179 

+	$wcsÿ£cmp_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+,
+
+180 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+182 

+	$wc¢ÿ£cmp_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+,
+
+183 
+size_t
+ 
+__n
+, 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+186 
+__BEGIN_NAMESPACE_STD
+
+
+189 

+	$wcscÞl
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+è
+__THROW
+;
+
+193 

+size_t
+ 
+	$wcsxäm
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+194 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+è
+__THROW
+;
+
+195 
+__END_NAMESPACE_STD
+
+
+197 #ifdeà
+__USE_XOPEN2K8
+
+
+203 

+	$wcscÞl_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s1
+, __cÚ¡ wch¬_ˆ*
+__s2
+,
+
+204 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+209 

+size_t
+ 
+	$wcsxäm_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‹_m®loc__
+;
+
+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
+ *
+	$wc¤chr
+ (
+wch¬_t
+ *
+__wcs
+, wch¬_ˆ
+__wc
+)
+
+230 
+__THROW
+ 
+	`__asm
+ ("wc¤chr"è
+__©Œibu‹_pu»__
+;
+
+231 
"C++" 
+__cÚ¡
+ 
+wch¬_t
+ *
+	$wc¤chr
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__wcs
+, wch¬_ˆ
+__wc
+)
+
+232 
+__THROW
+ 
+	`__asm
+ ("wc¤chr"è
+__©Œibu‹_pu»__
+;
+
+234 

+wch¬_t
+ *
+	$wc¤chr
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__wcs
+, wch¬_ˆ
+__wc
+)
+
+235 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+237 
+__END_NAMESPACE_STD
+
+
+239 #ifdeà
+__USE_GNU
+
+
+242 

+wch¬_t
+ *
+	$wcschºul
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s
+, wch¬_ˆ
+__wc
+)
+
+243 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+246 
+__BEGIN_NAMESPACE_STD
+
+
+249 

+size_t
+ 
+	$wcsc¥n
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__wcs
+, __cÚ¡ wch¬_ˆ*
+__»jeù
+)
+
+250 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+253 

+size_t
+ 
+	$wcs¥n
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__wcs
+, __cÚ¡ wch¬_ˆ*
+__acû±
+)
+
+254 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+256 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+257 
"C++" 
+wch¬_t
+ *
+	$wc¥brk
+ (
+wch¬_t
+ *
+__wcs
+, 
+__cÚ¡
+ wch¬_ˆ*
+__acû±
+)
+
+258 
+__THROW
+ 
+	`__asm
+ ("wc¥brk"è
+__©Œibu‹_pu»__
+;
+
+259 
"C++" 
+__cÚ¡
+ 
+wch¬_t
+ *
+	$wc¥brk
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__wcs
+,
+
+260 
+__cÚ¡
+ 
+wch¬_t
+ *
+__acû±
+)
+
+261 
+__THROW
+ 
+	`__asm
+ ("wc¥brk"è
+__©Œibu‹_pu»__
+;
+
+263 

+wch¬_t
+ *
+	$wc¥brk
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__wcs
+, __cÚ¡ wch¬_ˆ*
+__acû±
+)
+
+264 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+267 #ifdeà
+__CORRECT_ISO_CPP_WCHAR_H_PROTO
+
+
+268 
"C++" 
+wch¬_t
+ *
+	$wcs¡r
+ (
+wch¬_t
+ *
+__hay¡ack
+, 
+__cÚ¡
+ wch¬_ˆ*
+__ÃedË
+)
+
+269 
+__THROW
+ 
+	`__asm
+ ("wcs¡r"è
+__©Œibu‹_pu»__
+;
+
+270 
"C++" 
+__cÚ¡
+ 
+wch¬_t
+ *
+	$wcs¡r
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__hay¡ack
+,
+
+271 
+__cÚ¡
+ 
+wch¬_t
+ *
+__ÃedË
+)
+
+272 
+__THROW
+ 
+	`__asm
+ ("wcs¡r"è
+__©Œibu‹_pu»__
+;
+
+274 

+wch¬_t
+ *
+	$wcs¡r
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__hay¡ack
+, __cÚ¡ wch¬_ˆ*
+__ÃedË
+)
+
+275 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+279 

+wch¬_t
+ *
+	$wc¡ok
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+280 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__d–im
+,
+
+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
+ *
+__hay¡ack
+, 
+__cÚ¡
+ wch¬_ˆ*
+__ÃedË
+)
+
+291 
+__THROW
+ 
+	`__asm
+ ("wcswcs"è
+__©Œibu‹_pu»__
+;
+
+292 
"C++" 
+__cÚ¡
+ 
+wch¬_t
+ *
+	$wcswcs
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__hay¡ack
+,
+
+293 
+__cÚ¡
+ 
+wch¬_t
+ *
+__ÃedË
+)
+
+294 
+__THROW
+ 
+	`__asm
+ ("wcswcs"è
+__©Œibu‹_pu»__
+;
+
+296 

+wch¬_t
+ *
+	$wcswcs
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__hay¡ack
+, __cÚ¡ wch¬_ˆ*
+__ÃedË
+)
+
+297 
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+301 #ifdeà
+__USE_XOPEN2K8
+
+
+303 

+size_t
+ 
+	$wc¢Ën
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__s
+, 
+size_t
+ 
+__maxËn
+)
+
+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
+ *
+	$wmemýy
+ (
+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
+ *
+	$wmem£t
+ (
+wch¬_t
+ *
+__s
+, wch¬_ˆ
+__c
+, 
+size_t
+ 
+__n
+è
+__THROW
+;
+
+337 
+__END_NAMESPACE_STD
+
+
+339 #ifdeà
+__USE_GNU
+
+
+342 

+wch¬_t
+ *
+	$wmempýy
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+343 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+)
+
+344 
+__THROW
+;
+
+348 
+__BEGIN_NAMESPACE_STD
+
+
+351 

+wšt_t
+ 
+	$btowc
+ (
+__c
+è
+__THROW
+;
+
+355 

+	$wùob
+ (
+wšt_t
+ 
+__c
+è
+__THROW
+;
+
+359 

+	$mbsš™
+ (
+__cÚ¡
+ 
+mb¡©e_t
+ *
+__ps
+è
+__THROW
+ 
+__©Œibu‹_pu»__
+;
+
+363 

+size_t
+ 
+	$mb¹owc
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__pwc
+,
+
+364 
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+365 
+mb¡©e_t
+ *
+__p
+è
+__THROW
+;
+
+368 

+size_t
+ 
+	$wütomb
+ (*
+__»¡riù
+ 
+__s
+, 
+wch¬_t
+ 
+__wc
+,
+
+369 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+è
+__THROW
+;
+
+372 

+size_t
+ 
+	$__mb¾’
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+373 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+è
+__THROW
+;
+
+374 

+size_t
+ 
+	$mb¾’
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+375 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+è
+__THROW
+;
+
+376 
+__END_NAMESPACE_STD
+
+
+378 #ifdeà
+__USE_EXTERN_INLINES
+
+
+384 

+wšt_t
+ 
+	$__btowc_®Ÿs
+ (
+__c
+è
+	`__asm
+ ("btowc");
+
+385 
+__ex‹º_šlše
+ 
+wšt_t
+
+
+386 
+	`__NTH
+ (
+	$btowc
+ (
+__c
+))
+
+387 {  (
+	`__bužtš_cÚ¡ªt_p
+ (
+__c
+) && __c >= '\0' && __c <= '\x7f'
+
+388 ? (
+wšt_t
+è
+__c
+ : 
+	`__btowc_®Ÿs
+ (__c)); 
+	}
+}
+
+390 

+	$__wùob_®Ÿs
+ (
+wšt_t
+ 
+__c
+è
+	`__asm
+ ("wctob");
+
+391 
+__ex‹º_šlše
+ 
+
+392 
+	`__NTH
+ (
+	$wùob
+ (
+wšt_t
+ 
+__wc
+))
+
+393 {  (
+	`__bužtš_cÚ¡ªt_p
+ (
+__wc
+è&& __wø>ð
+L
+'\0' && __wc <= L'\x7f'
+
+394 ? (è
+__wc
+ : 
+	`__wùob_®Ÿs
+ (__wc)); 
+	}
+}
+
+396 
+__ex‹º_šlše
+ 
+size_t
+
+
+397 
+__NTH
+ (
+	$mb¾’
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+398 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+))
+
+399 {  (
+__ps
+ !ð
+NULL
+
+
+400 ? 
+	`mb¹owc
+ (
+NULL
+, 
+__s
+, 
+__n
+, 
+__ps
+è: 
+	`__mb¾’
+ (__s, __n, NULL)); 
+	}
+}
+
+403 
+__BEGIN_NAMESPACE_STD
+
+
+406 

+size_t
+ 
+	$mb¤towcs
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+407 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__Ën
+,
+
+408 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+è
+__THROW
+;
+
+412 

+size_t
+ 
+	$wc¤tombs
+ (*
+__»¡riù
+ 
+__d¡
+,
+
+413 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__Ën
+,
+
+414 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+è
+__THROW
+;
+
+415 
+__END_NAMESPACE_STD
+
+
+418 #ifdef 
+__USE_XOPEN2K8
+
+
+421 

+size_t
+ 
+	$mb¢¹owcs
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+422 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__nmc
+,
+
+423 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+è
+__THROW
+;
+
+427 

+size_t
+ 
+	$wc¢¹ombs
+ (*
+__»¡riù
+ 
+__d¡
+,
+
+428 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+429 
+size_t
+ 
+__nwc
+, size_ˆ
+__Ën
+,
+
+430 
+mb¡©e_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 

+	$wc¡od
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+449 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+è
+__THROW
+;
+
+450 
+__END_NAMESPACE_STD
+
+
+452 #ifdeà
+__USE_ISOC99
+
+
+453 
+__BEGIN_NAMESPACE_C99
+
+
+455 

+	$wc¡of
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+456 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+è
+__THROW
+;
+
+457 

+	$wc¡Þd
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+458 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+è
+__THROW
+;
+
+459 
+__END_NAMESPACE_C99
+
+
+463 
+__BEGIN_NAMESPACE_STD
+
+
+466 

+	$wc¡Þ
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+467 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__ba£
+è
+__THROW
+;
+
+471 

+	$wc¡oul
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+472 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__ba£
+)
+
+473 
+__THROW
+;
+
+474 
+__END_NAMESPACE_STD
+
+
+476 #ià
+defšed
+ 
+__USE_ISOC99
+ || (defšed 
+__GNUC__
+ && defšed 
+__USE_GNU
+)
+
+477 
+__BEGIN_NAMESPACE_C99
+
+
+480 
+__ex‹nsiÚ__
+
+
+481 

+	$wc¡Þl
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+482 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__ba£
+)
+
+483 
+__THROW
+;
+
+487 
+__ex‹nsiÚ__
+
+
+488 

+	$wc¡ouÎ
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+489 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+,
+
+490 
+__ba£
+è
+__THROW
+;
+
+491 
+__END_NAMESPACE_C99
+
+
+494 #ià
+defšed
+ 
+__GNUC__
+ && defšed 
+__USE_GNU
+
+
+497 
+__ex‹nsiÚ__
+
+
+498 

+	$wc¡oq
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+499 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__ba£
+)
+
+500 
+__THROW
+;
+
+504 
+__ex‹nsiÚ__
+
+
+505 

+	$wc¡ouq
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+506 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+,
+
+507 
+__ba£
+è
+__THROW
+;
+
+510 #ifdeà
+__USE_GNU
+
+
+524 
+	~<xloÿË.h
+>
+
+528 

+	$wc¡Þ_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+529 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__ba£
+,
+
+530 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+532 

+	$wc¡oul_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+533 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+,
+
+534 
+__ba£
+, 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+536 
+__ex‹nsiÚ__
+
+
+537 

+	$wc¡Þl_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+538 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+,
+
+539 
+__ba£
+, 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+541 
+__ex‹nsiÚ__
+
+
+542 

+	$wc¡ouÎ_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+543 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+,
+
+544 
+__ba£
+, 
+__loÿË_t
+ 
+__loc
+)
+
+545 
+__THROW
+;
+
+547 

+	$wc¡od_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+548 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__loÿË_t
+ 
+__loc
+)
+
+549 
+__THROW
+;
+
+551 

+	$wc¡of_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+552 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+, 
+__loÿË_t
+ 
+__loc
+)
+
+553 
+__THROW
+;
+
+555 

+	$wc¡Þd_l
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__Ō
+,
+
+556 
+wch¬_t
+ **
+__»¡riù
+ 
+__’d±r
+,
+
+557 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+561 #ifdef 
+__USE_XOPEN2K8
+
+
+564 

+wch¬_t
+ *
+	$wýýy
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+è
+__THROW
+;
+
+568 

+wch¬_t
+ *
+	$wýnýy
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+, 
+size_t
+ 
+__n
+)
+
+569 
+__THROW
+;
+
+575 #ifdef 
+__USE_XOPEN2K8
+
+
+578 

+__FILE
+ *
+	$Ý’_wmem¡»am
+ (
+wch¬_t
+ **
+__buæoc
+, 
+size_t
+ *
+__siz–oc
+è
+__THROW
+;
+
+581 #ià
+defšed
+ 
+__USE_ISOC95
+ || defšed 
+__USE_UNIX98
+
+
+582 
+__BEGIN_NAMESPACE_STD
+
+
+585 

+	$fwide
+ (
+__FILE
+ *
+__å
+, 
+__mode
+è
+__THROW
+;
+
+592 

+	`fw´štf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+593 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+599 

+	`w´štf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+602 

+	$sw´štf
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+603 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+604 
+__THROW
+ ;
+
+610 

+	`vfw´štf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__s
+,
+
+611 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+612 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+618 

+	`vw´štf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+619 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+623 

+	$vsw´štf
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+624 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+625 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+626 
+__THROW
+ ;
+
+633 

+	`fwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+634 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+640 

+	`wsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+643 

+	$swsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+644 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+645 
+__THROW
+ ;
+
+647 #ià
+defšed
+ 
+__USE_ISOC99
+ && !defšed 
+__USE_GNU
+ \
+
+648 && (!
+defšed
+ 
+__LDBL_COMPAT
+ || !defšed 
+__REDIRECT
+) \
+
+649 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+650 #ifdeà
+__REDIRECT
+
+
+654 

+	`__REDIRECT
+ (
+fwsÿnf
+, (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+655 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...),
+
+656 
+__isoc99_fwsÿnf
+)
+
+658 

+	`__REDIRECT
+ (
+wsÿnf
+, (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...),
+
+659 
+__isoc99_wsÿnf
+)
+
+661 

+	`__REDIRECT
+ (
+swsÿnf
+, (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+662 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...),
+
+663 
+__isoc99_swsÿnf
+)
+
+664 
+__THROW
+ ;
+
+666 

+	`__isoc99_fwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+667 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+668 

+	`__isoc99_wsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+669 

+	$__isoc99_swsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+670 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+671 
+__THROW
+;
+
+672 

+	#fwsÿnf
+ 
+__isoc99_fwsÿnf
+
+
+	)
+
+673 

+	#wsÿnf
+ 
+__isoc99_wsÿnf
+
+
+	)
+
+674 

+	#swsÿnf
+ 
+__isoc99_swsÿnf
+
+
+	)
+
+678 
+__END_NAMESPACE_STD
+
+
+681 #ifdeà
+__USE_ISOC99
+
+
+682 
+__BEGIN_NAMESPACE_C99
+
+
+687 

+	`vfwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__s
+,
+
+688 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+689 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+695 

+	`vwsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+696 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+699 

+	$vswsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+700 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+701 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+702 
+__THROW
+ ;
+
+704 #ià!
+defšed
+ 
+__USE_GNU
+ \
+
+705 && (!
+defšed
+ 
+__LDBL_COMPAT
+ || !defšed 
+__REDIRECT
+) \
+
+706 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+707 #ifdeà
+__REDIRECT
+
+
+708 

+	`__REDIRECT
+ (
+vfwsÿnf
+, (
+__FILE
+ *
+__»¡riù
+ 
+__s
+,
+
+709 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+710 
+__gnuc_va_li¡
+ 
+__¬g
+), 
+__isoc99_vfwsÿnf
+)
+
+712 

+	`__REDIRECT
+ (
+vwsÿnf
+, (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+713 
+__gnuc_va_li¡
+ 
+__¬g
+), 
+__isoc99_vwsÿnf
+)
+
+715 

+	`__REDIRECT
+ (
+vswsÿnf
+, (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+716 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+717 
+__gnuc_va_li¡
+ 
+__¬g
+), 
+__isoc99_vswsÿnf
+)
+
+718 
+__THROW
+ ;
+
+720 

+	`__isoc99_vfwsÿnf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__s
+,
+
+721 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+722 
+__gnuc_va_li¡
+ 
+__¬g
+);
+
+723 

+	`__isoc99_vwsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+724 
+__gnuc_va_li¡
+ 
+__¬g
+);
+
+725 

+	$__isoc99_vswsÿnf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+,
+
+726 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+727 
+__gnuc_va_li¡
+ 
+__¬g
+è
+__THROW
+;
+
+728 

+	#vfwsÿnf
+ 
+__isoc99_vfwsÿnf
+
+
+	)
+
+729 

+	#vwsÿnf
+ 
+__isoc99_vwsÿnf
+
+
+	)
+
+730 

+	#vswsÿnf
+ 
+__isoc99_vswsÿnf
+
+
+	)
+
+734 
+__END_NAMESPACE_C99
+
+
+738 
+__BEGIN_NAMESPACE_STD
+
+
+743 

+wšt_t
+ 
+	`fg‘wc
+ (
+__FILE
+ *
+__¡»am
+);
+
+744 

+wšt_t
+ 
+	`g‘wc
+ (
+__FILE
+ *
+__¡»am
+);
+
+750 

+wšt_t
+ 
+	`g‘wch¬
+ ();
+
+757 

+wšt_t
+ 
+	`åutwc
+ (
+wch¬_t
+ 
+__wc
+, 
+__FILE
+ *
+__¡»am
+);
+
+758 

+wšt_t
+ 
+	`putwc
+ (
+wch¬_t
+ 
+__wc
+, 
+__FILE
+ *
+__¡»am
+);
+
+764 

+wšt_t
+ 
+	`putwch¬
+ (
+wch¬_t
+ 
+__wc
+);
+
+772 

+wch¬_t
+ *
+	`fg‘ws
+ (wch¬_ˆ*
+__»¡riù
+ 
+__ws
+, 
+__n
+,
+
+773 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+);
+
+779 

+	`åutws
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__ws
+,
+
+780 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+);
+
+787 

+wšt_t
+ 
+	`ung‘wc
+ (wšt_ˆ
+__wc
+, 
+__FILE
+ *
+__¡»am
+);
+
+788 
+__END_NAMESPACE_STD
+
+
+791 #ifdeà
+__USE_GNU
+
+
+799 

+wšt_t
+ 
+	`g‘wc_uÆocked
+ (
+__FILE
+ *
+__¡»am
+);
+
+800 

+wšt_t
+ 
+	`g‘wch¬_uÆocked
+ ();
+
+808 

+wšt_t
+ 
+	`fg‘wc_uÆocked
+ (
+__FILE
+ *
+__¡»am
+);
+
+816 

+wšt_t
+ 
+	`åutwc_uÆocked
+ (
+wch¬_t
+ 
+__wc
+, 
+__FILE
+ *
+__¡»am
+);
+
+825 

+wšt_t
+ 
+	`putwc_uÆocked
+ (
+wch¬_t
+ 
+__wc
+, 
+__FILE
+ *
+__¡»am
+);
+
+826 

+wšt_t
+ 
+	`putwch¬_uÆocked
+ (
+wch¬_t
+ 
+__wc
+);
+
+835 

+wch¬_t
+ *
+	`fg‘ws_uÆocked
+ (wch¬_ˆ*
+__»¡riù
+ 
+__ws
+, 
+__n
+,
+
+836 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+);
+
+844 

+	`åutws_uÆocked
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__ws
+,
+
+845 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+);
+
+849 
+__BEGIN_NAMESPACE_C99
+
+
+853 

+size_t
+ 
+	$wcsáime
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__maxsize
+,
+
+854 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+855 
+__cÚ¡
+ 
+tm
+ *
+__»¡riù
+ 
+__�
+è
+__THROW
+;
+
+856 
+__END_NAMESPACE_C99
+
+
+858 #ifdeà
+__USE_GNU
+
+
+859 
+	~<xloÿË.h
+>
+
+863 

+size_t
+ 
+	$wcsáime_l
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__maxsize
+,
+
+864 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+865 
+__cÚ¡
+ 
+tm
+ *
+__»¡riù
+ 
+__�
+,
+
+866 
+__loÿË_t
+ 
+__loc
+è
+__THROW
+;
+
+875 #ià
+defšed
+ 
+__USE_UNIX98
+ && !defšed 
+__USE_GNU
+
+
+876 

+	#__Ãed_iswxxx
+
+
+	)
+
+877 
+	~<wùy³.h
+>
+
+881 #ià
+__USE_FORTIFY_LEVEL
+ > 0 && 
+defšed
+ 
+__ex‹º_®ways_šlše
+
+
+882 
+	~<b™s/wch¬2.h
+>
+
+885 #ifdeà
+__LDBL_COMPAT
+
+
+886 
+	~<b™s/wch¬-ldbl.h
+>
+
+889 
+__END_DECLS
+
+
+897 #undeà
+__Ãed_mb¡©e_t
+
+
+898 #undeà
+__Ãed_wšt_t
+
+
+	@/usr/include/xlocale.h
+
+21 #iâdeà
+_XLOCALE_H
+
+
+22 

+	#_XLOCALE_H
+ 1
+
+	)
+
+28 
+	s__loÿË_¡ruù
+
+
+31 
+loÿË_d©a
+ *
+	m__loÿËs
+[13];
+
+34 cÚ¡ *
+	m__ùy³_b
+;
+
+35 cÚ¡ *
+	m__ùy³_tÞow”
+;
+
+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à!
+defšed
+ 
+_BYTESWAP_H
+ && !defšed 
+_NETINET_IN_H
+ && !defšed 
+_ENDIAN_H
+
+
+25 #iâdeà
+_BITS_BYTESWAP_H
+
+
+26 

+	#_BITS_BYTESWAP_H
+ 1
+
+	)
+
+28 
+	~<b™s/wÜdsize.h
+>
+
+31 

+	#__bsw­_cÚ¡ªt_16
+(
+x
+) \
+
+32 ((((
+x
+è>> 8è& 0xffè| (((xè& 0xffè<< 8))
+
+	)
+
+34 #ià
+defšed
+ 
+__GNUC__
+ && __GNUC__ >= 2
+
+35 

+	#__bsw­_16
+(
+x
+) \
+
+36 (
+__ex‹nsiÚ__
+ \
+
+37 ({ 
+__v
+, 
+__x
+ = (
+x
+); \
+
+38 ià(
+	`__bužtš_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 (
+__ex‹nsiÚ__
+ \
+
+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à
+defšed
+ 
+__GNUC__
+ && __GNUC__ >= 2
+
+60 #ià
+__WORDSIZE
+ =ð64 || (
+defšed
+ 
+__i486__
+ || defšed 
+__³Áium__
+ \
+
+61 || 
+defšed
+ 
+	g__³Áium´o__
+ || defšed 
+	g__³Áium4__
+ \
+
+62 || 
+defšed
+ 
+	g__k8__
+ || defšed 
+	g__©hlÚ__
+ \
+
+63 || 
+defšed
+ 
+	g__k6__
+ || defšed 
+	g__nocÚa__
+ \
+
+64 || 
+defšed
+ 
+	g__cÜe2__
+ || defšed 
+	g__geode__
+ \
+
+65 || 
+defšed
+ 
+	g__amdçm10__
+)
+
+68 

+	#__bsw­_32
+(
+x
+) \
+
+69 (
+__ex‹nsiÚ__
+ \
+
+70 ({ 
+__v
+, 
+__x
+ = (
+x
+); \
+
+71 ià(
+	`__bužtš_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 (
+__ex‹nsiÚ__
+ \
+
+79 ({ 
+__v
+, 
+__x
+ = (
+x
+); \
+
+80 ià(
+	`__bužtš_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 (
+__ex‹nsiÚ__
+ \
+
+94 ({ 
+__x
+ = (
+x
+); 
+	`__bsw­_cÚ¡ªt_32
+ (__x); }))
+
+	)
+
+98 #ià
+defšed
+ 
+__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 (
+__ex‹nsiÚ__
+ \
+
+113 ({ 
+__v
+, 
+__x
+ = (
+x
+); \
+
+114 ià(
+	`__bužtš_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 (
+__ex‹nsiÚ__
+ \
+
+122 ({ uniÚ { 
+__ex‹nsiÚ__
+ 
+__Î
+; \
+
+123 
+__l
+[2]; } 
+__w
+, 
+__r
+; \
+
+124 ià(
+	`__bužtš_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 #iâdeà
+_ENDIAN_H
+
+
+7 

+	#__BYTE_ORDER
+ 
+__LITTLE_ENDIAN
+
+
+	)
+
+	@/usr/include/bits/wchar-ldbl.h
+
+20 #iâdeà
+_WCHAR_H
+
+
+24 #ià
+defšed
+ 
+__USE_ISOC95
+ || defšed 
+__USE_UNIX98
+
+
+25 
+__BEGIN_NAMESPACE_C99
+
+
+26 
+__LDBL_REDIR_DECL
+ (
+fw´štf
+);
+
+27 
+__LDBL_REDIR_DECL
+ (
+w´štf
+);
+
+28 
+__LDBL_REDIR_DECL
+ (
+sw´štf
+);
+
+29 
+__LDBL_REDIR_DECL
+ (
+vfw´štf
+);
+
+30 
+__LDBL_REDIR_DECL
+ (
+vw´štf
+);
+
+31 
+__LDBL_REDIR_DECL
+ (
+vsw´štf
+);
+
+32 #ià
+defšed
+ 
+__USE_ISOC99
+ && !defšed 
+__USE_GNU
+ \
+
+33 && !
+defšed
+ 
+	g__REDIRECT
+ \
+
+34 && (
+defšed
+ 
+	g__STRICT_ANSI__
+ || defšed 
+	g__USE_XOPEN2K
+)
+
+35 
+	$__LDBL_REDIR1_DECL
+ (
+fwsÿnf
+, 
+__Ædbl___isoc99_fwsÿnf
+)
+
+36 
+	$__LDBL_REDIR1_DECL
+ (
+wsÿnf
+, 
+__Ædbl___isoc99_wsÿnf
+)
+
+37 
+	$__LDBL_REDIR1_DECL
+ (
+swsÿnf
+, 
+__Ædbl___isoc99_swsÿnf
+)
+
+39 
+	`__LDBL_REDIR_DECL
+ (
+fwsÿnf
+);
+
+40 
+	`__LDBL_REDIR_DECL
+ (
+wsÿnf
+);
+
+41 
+	`__LDBL_REDIR_DECL
+ (
+swsÿnf
+);
+
+43 
+__END_NAMESPACE_C99
+
+
+46 #ifdeà
+__USE_ISOC99
+
+
+47 
+__BEGIN_NAMESPACE_C99
+
+
+48 
+	`__LDBL_REDIR1_DECL
+ (
+wc¡Þd
+, 
+wc¡od
+);
+
+49 #ià!
+defšed
+ 
+__USE_GNU
+ && !defšed 
+__REDIRECT
+ \
+
+50 && (
+defšed
+ 
+__STRICT_ANSI__
+ || defšed 
+__USE_XOPEN2K
+)
+
+51 
+	$__LDBL_REDIR1_DECL
+ (
+vfwsÿnf
+, 
+__Ædbl___isoc99_vfwsÿnf
+)
+
+52 
+	$__LDBL_REDIR1_DECL
+ (
+vwsÿnf
+, 
+__Ædbl___isoc99_vwsÿnf
+)
+
+53 
+	$__LDBL_REDIR1_DECL
+ (
+vswsÿnf
+, 
+__Ædbl___isoc99_vswsÿnf
+)
+
+55 
+	`__LDBL_REDIR_DECL
+ (
+vfwsÿnf
+);
+
+56 
+	`__LDBL_REDIR_DECL
+ (
+vwsÿnf
+);
+
+57 
+	`__LDBL_REDIR_DECL
+ (
+vswsÿnf
+);
+
+59 
+__END_NAMESPACE_C99
+
+
+62 #ifdeà
+__USE_GNU
+
+
+63 
+	`__LDBL_REDIR1_DECL
+ (
+wc¡Þd_l
+, 
+wc¡od_l
+);
+
+66 #ià
+__USE_FORTIFY_LEVEL
+ > 0 && 
+defšed
+ 
+__ex‹º_®ways_šlše
+
+
+67 
+	$__LDBL_REDIR_DECL
+ (
+__sw´štf_chk
+)
+
+68 
+	$__LDBL_REDIR_DECL
+ (
+__vsw´štf_chk
+)
+
+69 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+70 
+	$__LDBL_REDIR_DECL
+ (
+__fw´štf_chk
+)
+
+71 
+	$__LDBL_REDIR_DECL
+ (
+__w´štf_chk
+)
+
+72 
+	$__LDBL_REDIR_DECL
+ (
+__vfw´štf_chk
+)
+
+73 
+	$__LDBL_REDIR_DECL
+ (
+__vw´štf_chk
+)
+
+	@/usr/include/bits/wchar.h
+
+20 #iâdeà
+_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 #iâdeà
+_WCHAR_H
+
+
+25 

+wch¬_t
+ *
+	$__wmemýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+26 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+,
+
+27 
+size_t
+ 
+__ns1
+è
+__THROW
+;
+
+28 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wmemýy_®Ÿs
+,
+
+29 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+30 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+),
+
+31 
+wmemýy
+);
+
+32 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wmemýy_chk_w¬n
+,
+
+33 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+34 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+,
+
+35 
+size_t
+ 
+__ns1
+), 
+__wmemýy_chk
+)
+
+36 
+	`__w¬Ç‰r
+ ("wmemcpy called with†ength bigger�han size of destination "
+
+39 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+40 
+	`__NTH
+ (
+	$wmemýy
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+, 
+__cÚ¡
+ wch¬_ˆ*__»¡riù 
+__s2
+,
+
+41 
+size_t
+ 
+__n
+))
+
+43 ià(
+	`__bos0
+ (
+__s1
+è!ð(
+size_t
+) -1)
+
+45 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+))
+
+46  
+	`__wmemýy_chk
+ (
+__s1
+, 
+__s2
+, 
+__n
+,
+
+47 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+));
+
+49 ià(
+__n
+ > 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+))
+
+50  
+	`__wmemýy_chk_w¬n
+ (
+__s1
+, 
+__s2
+, 
+__n
+,
+
+51 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+));
+
+53  
+	`__wmemýy_®Ÿ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_w¬n
+,
+
+63 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+64 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+,
+
+65 
+size_t
+ 
+__ns1
+), 
+__wmemmove_chk
+)
+
+66 
+	`__w¬Ç‰r
+ ("wmemmove called with†ength bigger�han size of destination "
+
+69 
+__ex‹º_®ways_šlše
+ 
+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à(!
+	`__bužtš_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_w¬n
+ (
+__s1
+, 
+__s2
+, 
+__n
+,
+
+81 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+));
+
+83  
+	`__wmemmove_®Ÿs
+ (
+__s1
+, 
+__s2
+, 
+__n
+);
+
+84 
+	}
+}
+
+87 #ifdeà
+__USE_GNU
+
+
+88 

+wch¬_t
+ *
+	$__wmempýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+89 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+,
+
+90 
+size_t
+ 
+__ns1
+è
+__THROW
+;
+
+91 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wmempýy_®Ÿs
+,
+
+92 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+93 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+,
+
+94 
+size_t
+ 
+__n
+), 
+wmempýy
+);
+
+95 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wmempýy_chk_w¬n
+,
+
+96 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+,
+
+97 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__s2
+, 
+size_t
+ 
+__n
+,
+
+98 
+size_t
+ 
+__ns1
+), 
+__wmempýy_chk
+)
+
+99 
+	`__w¬Ç‰r
+ ("wmempcpy called with†ength bigger�han size of destination "
+
+102 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+103 
+	`__NTH
+ (
+	$wmempýy
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s1
+, 
+__cÚ¡
+ wch¬_ˆ*__»¡riù 
+__s2
+,
+
+104 
+size_t
+ 
+__n
+))
+
+106 ià(
+	`__bos0
+ (
+__s1
+è!ð(
+size_t
+) -1)
+
+108 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+))
+
+109  
+	`__wmempýy_chk
+ (
+__s1
+, 
+__s2
+, 
+__n
+,
+
+110 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+));
+
+112 ià(
+__n
+ > 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+))
+
+113  
+	`__wmempýy_chk_w¬n
+ (
+__s1
+, 
+__s2
+, 
+__n
+,
+
+114 
+	`__bos0
+ (
+__s1
+è/  (
+wch¬_t
+));
+
+116  
+	`__wmempýy_®Ÿs
+ (
+__s1
+, 
+__s2
+, 
+__n
+);
+
+117 
+	}
+}
+
+121 

+wch¬_t
+ *
+	$__wmem£t_chk
+ (
+wch¬_t
+ *
+__s
+, wch¬_ˆ
+__c
+, 
+size_t
+ 
+__n
+,
+
+122 
+size_t
+ 
+__ns
+è
+__THROW
+;
+
+123 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wmem£t_®Ÿs
+, (wch¬_ˆ*
+__s
+, wch¬_ˆ
+__c
+,
+
+124 
+size_t
+ 
+__n
+), 
+wmem£t
+);
+
+125 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wmem£t_chk_w¬n
+,
+
+126 (
+wch¬_t
+ *
+__s
+, wch¬_ˆ
+__c
+, 
+size_t
+ 
+__n
+,
+
+127 
+size_t
+ 
+__ns
+), 
+__wmem£t_chk
+)
+
+128 
+	`__w¬Ç‰r
+ ("wmemset called with†ength bigger�han size of destination "
+
+131 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+132 
+	`__NTH
+ (
+	$wmem£t
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, wch¬_ˆ
+__c
+, 
+size_t
+ 
+__n
+))
+
+134 ià(
+	`__bos0
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+136 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+))
+
+137  
+	`__wmem£t_chk
+ (
+__s
+, 
+__c
+, 
+__n
+, 
+	`__bos0
+ (__sè/  (
+wch¬_t
+));
+
+139 ià(
+__n
+ > 
+	`__bos0
+ (
+__s
+è/  (
+wch¬_t
+))
+
+140  
+	`__wmem£t_chk_w¬n
+ (
+__s
+, 
+__c
+, 
+__n
+,
+
+141 
+	`__bos0
+ (
+__s
+è/  (
+wch¬_t
+));
+
+143  
+	`__wmem£t_®Ÿs
+ (
+__s
+, 
+__c
+, 
+__n
+);
+
+144 
+	}
+}
+
+147 

+wch¬_t
+ *
+	$__wcsýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+148 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+149 
+size_t
+ 
+__n
+è
+__THROW
+;
+
+150 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wcsýy_®Ÿs
+,
+
+151 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+152 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+), 
+wcsýy
+);
+
+154 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+155 
+	`__NTH
+ (
+	$wcsýy
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+))
+
+157 ià(
+	`__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+158  
+	`__wcsýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+	`__bos
+ (__de¡è/  (
+wch¬_t
+));
+
+159  
+	`__wcsýy_®Ÿs
+ (
+__de¡
+, 
+__¤c
+);
+
+160 
+	}
+}
+
+163 

+wch¬_t
+ *
+	$__wýýy_chk
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+,
+
+164 
+size_t
+ 
+__de¡Ën
+è
+__THROW
+;
+
+165 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wýýy_®Ÿs
+, (wch¬_ˆ*
+__de¡
+,
+
+166 
+__cÚ¡
+ 
+wch¬_t
+ *
+__¤c
+),
+
+167 
+wýýy
+);
+
+169 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+170 
+	`__NTH
+ (
+	$wýýy
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+))
+
+172 ià(
+	`__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+173  
+	`__wýýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+	`__bos
+ (__de¡è/  (
+wch¬_t
+));
+
+174  
+	`__wýýy_®Ÿs
+ (
+__de¡
+, 
+__¤c
+);
+
+175 
+	}
+}
+
+178 

+wch¬_t
+ *
+	$__wc¢ýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+179 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__n
+,
+
+180 
+size_t
+ 
+__de¡Ën
+è
+__THROW
+;
+
+181 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wc¢ýy_®Ÿs
+,
+
+182 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+183 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+184 
+size_t
+ 
+__n
+), 
+wc¢ýy
+);
+
+185 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wc¢ýy_chk_w¬n
+,
+
+186 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+187 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+188 
+size_t
+ 
+__n
+, size_ˆ
+__de¡Ën
+), 
+__wc¢ýy_chk
+)
+
+189 
+	`__w¬Ç‰r
+ ("wcsncpy called with†ength bigger�han size of destination "
+
+192 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+193 
+	`__NTH
+ (
+	$wc¢ýy
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+, 
+size_t
+ 
+__n
+))
+
+195 ià(
+	`__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+197 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+))
+
+198  
+	`__wc¢ýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+,
+
+199 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+));
+
+200 ià(
+__n
+ > 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+))
+
+201  
+	`__wc¢ýy_chk_w¬n
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+,
+
+202 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+));
+
+204  
+	`__wc¢ýy_®Ÿs
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+);
+
+205 
+	}
+}
+
+208 

+wch¬_t
+ *
+	$__wýnýy_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+209 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__n
+,
+
+210 
+size_t
+ 
+__de¡Ën
+è
+__THROW
+;
+
+211 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wýnýy_®Ÿs
+,
+
+212 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+213 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+214 
+size_t
+ 
+__n
+), 
+wýnýy
+);
+
+215 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wýnýy_chk_w¬n
+,
+
+216 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+217 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+218 
+size_t
+ 
+__n
+, size_ˆ
+__de¡Ën
+), 
+__wýnýy_chk
+)
+
+219 
+	`__w¬Ç‰r
+ ("wcpncpy called with†ength bigger�han size of destination "
+
+222 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+223 
+	`__NTH
+ (
+	$wýnýy
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+, 
+size_t
+ 
+__n
+))
+
+225 ià(
+	`__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+227 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+))
+
+228  
+	`__wýnýy_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+,
+
+229 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+));
+
+230 ià(
+__n
+ > 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+))
+
+231  
+	`__wýnýy_chk_w¬n
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+,
+
+232 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+));
+
+234  
+	`__wýnýy_®Ÿs
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+);
+
+235 
+	}
+}
+
+238 

+wch¬_t
+ *
+	$__wcsÿt_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+239 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+240 
+size_t
+ 
+__de¡Ën
+è
+__THROW
+;
+
+241 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wcsÿt_®Ÿs
+,
+
+242 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+243 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+), 
+wcsÿt
+);
+
+245 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+246 
+	`__NTH
+ (
+	$wcsÿt
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+))
+
+248 ià(
+	`__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+249  
+	`__wcsÿt_chk
+ (
+__de¡
+, 
+__¤c
+, 
+	`__bos
+ (__de¡è/  (
+wch¬_t
+));
+
+250  
+	`__wcsÿt_®Ÿs
+ (
+__de¡
+, 
+__¤c
+);
+
+251 
+	}
+}
+
+254 

+wch¬_t
+ *
+	$__wc¢ÿt_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+255 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+256 
+size_t
+ 
+__n
+, size_ˆ
+__de¡Ën
+è
+__THROW
+;
+
+257 

+wch¬_t
+ *
+	`__REDIRECT_NTH
+ (
+__wc¢ÿt_®Ÿs
+,
+
+258 (
+wch¬_t
+ *
+__»¡riù
+ 
+__de¡
+,
+
+259 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__¤c
+,
+
+260 
+size_t
+ 
+__n
+), 
+wc¢ÿt
+);
+
+262 
+__ex‹º_®ways_šlše
+ 
+wch¬_t
+ *
+
+263 
+	`__NTH
+ (
+	$wc¢ÿt
+ (
+wch¬_t
+ *
+__de¡
+, 
+__cÚ¡
+ wch¬_ˆ*
+__¤c
+, 
+size_t
+ 
+__n
+))
+
+265 ià(
+	`__bos
+ (
+__de¡
+è!ð(
+size_t
+) -1)
+
+266  
+	`__wc¢ÿt_chk
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+,
+
+267 
+	`__bos
+ (
+__de¡
+è/  (
+wch¬_t
+));
+
+268  
+	`__wc¢ÿt_®Ÿs
+ (
+__de¡
+, 
+__¤c
+, 
+__n
+);
+
+269 
+	}
+}
+
+272 

+	$__sw´štf_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+273 
+__æag
+, 
+size_t
+ 
+__s_Ën
+,
+
+274 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...)
+
+275 
+__THROW
+ ;
+
+277 

+	`__REDIRECT_NTH_LDBL
+ (
+__sw´štf_®Ÿs
+,
+
+278 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+279 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fmt
+, ...),
+
+280 
+sw´štf
+);
+
+282 #ifdeà
+__va_¬g_·ck
+
+
+283 
+__ex‹º_®ways_šlše
+ 
+
+284 
+	`__NTH
+ (
+	$sw´štf
+ (
+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  
+	`__sw´štf_chk
+ (
+__s
+, 
+__n
+, 
+__USE_FORTIFY_LEVEL
+ - 1,
+
+289 
+	`__bos
+ (
+__s
+è/  (
+wch¬_t
+),
+
+290 
+__fmt
+, 
+	`__va_¬g_·ck
+ ());
+
+291  
+	`__sw´štf_®Ÿs
+ (
+__s
+, 
+__n
+, 
+__fmt
+, 
+	`__va_¬g_·ck
+ ());
+
+292 
+	}
+}
+
+293 #–ià!
+defšed
+ 
+__ýlu¥lus
+
+
+295 

+	#sw´štf
+(
+s
+, 
+n
+, ...) \
+
+296 (
+	`__bos
+ (
+s
+è!ð(
+size_t
+è-1 || 
+__USE_FORTIFY_LEVEL
+ > 1 \
+
+297 ? 
+	`__sw´štf_chk
+ (
+s
+, 
+n
+, 
+__USE_FORTIFY_LEVEL
+ - 1, \
+
+298 
+	`__bos
+ (
+s
+è/  (
+wch¬_t
+), 
+__VA_ARGS__
+) \
+
+299 : 
+	`sw´štf
+ (
+s
+, 
+n
+, 
+__VA_ARGS__
+))
+
+	)
+
+302 

+	$__vsw´štf_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+303 
+__æag
+, 
+size_t
+ 
+__s_Ën
+,
+
+304 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+305 
+__gnuc_va_li¡
+ 
+__¬g
+)
+
+306 
+__THROW
+ ;
+
+308 

+	`__REDIRECT_NTH_LDBL
+ (
+__vsw´štf_®Ÿs
+,
+
+309 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__n
+,
+
+310 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fmt
+,
+
+311 
+__gnuc_va_li¡
+ 
+__­
+), 
+vsw´štf
+);
+
+313 
+__ex‹º_®ways_šlše
+ 
+
+314 
+	`__NTH
+ (
+	$vsw´štf
+ (
+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  
+	`__vsw´štf_chk
+ (
+__s
+, 
+__n
+, 
+__USE_FORTIFY_LEVEL
+ - 1,
+
+319 
+	`__bos
+ (
+__s
+è/  (
+wch¬_t
+), 
+__fmt
+, 
+__­
+);
+
+320  
+	`__vsw´štf_®Ÿs
+ (
+__s
+, 
+__n
+, 
+__fmt
+, 
+__­
+);
+
+321 
+	}
+}
+
+324 #ià
+__USE_FORTIFY_LEVEL
+ > 1
+
+326 

+__fw´štf_chk
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+__æag
+,
+
+327 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+, ...);
+
+328 

+__w´štf_chk
+ (
+__æag
+, 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+330 

+__vfw´štf_chk
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+__æag
+,
+
+331 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+332 
+__gnuc_va_li¡
+ 
+__­
+);
+
+333 

+__vw´štf_chk
+ (
+__æag
+, 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+334 
+__gnuc_va_li¡
+ 
+__­
+);
+
+336 #ifdeà
+__va_¬g_·ck
+
+
+337 
+__ex‹º_®ways_šlše
+ 
+
+338 
+	$w´štf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fmt
+, ...)
+
+340  
+	`__w´štf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+	`__va_¬g_·ck
+ ());
+
+341 
+	}
+}
+
+343 
+__ex‹º_®ways_šlše
+ 
+
+344 
+	$fw´štf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+, 
+__cÚ¡
+ 
+wch¬_t
+ *__»¡riù 
+__fmt
+, ...)
+
+346  
+	`__fw´štf_chk
+ (
+__¡»am
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+,
+
+347 
+	`__va_¬g_·ck
+ ());
+
+348 
+	}
+}
+
+349 #–ià!
+defšed
+ 
+__ýlu¥lus
+
+
+350 

+	#w´štf
+(...) \
+
+351 
+	`__w´štf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+352 

+	#fw´štf
+(
+¡»am
+, ...) \
+
+353 
+	`__fw´štf_chk
+ (
+¡»am
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__VA_ARGS__
+)
+
+	)
+
+356 
+__ex‹º_®ways_šlše
+ 
+
+357 
+	$vw´štf
+ (
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fmt
+, 
+__gnuc_va_li¡
+ 
+__­
+)
+
+359  
+	`__vw´štf_chk
+ (
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+360 
+	}
+}
+
+362 
+__ex‹º_®ways_šlše
+ 
+
+363 
+	$vfw´štf
+ (
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+,
+
+364 
+__cÚ¡
+ 
+wch¬_t
+ *
+__»¡riù
+ 
+__fmt
+, 
+__gnuc_va_li¡
+ 
+__­
+)
+
+366  
+	`__vfw´štf_chk
+ (
+__¡»am
+, 
+__USE_FORTIFY_LEVEL
+ - 1, 
+__fmt
+, 
+__­
+);
+
+367 
+	}
+}
+
+371 

+wch¬_t
+ *
+	$__fg‘ws_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+, 
+__n
+,
+
+372 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+è
+__wur
+;
+
+373 

+wch¬_t
+ *
+	`__REDIRECT
+ (
+__fg‘ws_®Ÿs
+,
+
+374 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+__n
+,
+
+375 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+fg‘ws
+è
+__wur
+;
+
+376 

+wch¬_t
+ *
+	`__REDIRECT
+ (
+__fg‘ws_chk_w¬n
+,
+
+377 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+, 
+__n
+,
+
+378 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+__fg‘ws_chk
+)
+
+379 
+__wur
+ 
+	`__w¬Ç‰r
+ ("fgetws called with bigger size�han†ength "
+
+382 
+__ex‹º_®ways_šlše
+ 
+__wur
+ 
+wch¬_t
+ *
+
+383 
+	$fg‘ws
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+__n
+, 
+__FILE
+ *__»¡riù 
+__¡»am
+)
+
+385 ià(
+	`__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+387 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+388  
+	`__fg‘ws_chk
+ (
+__s
+, 
+	`__bos
+ (__sè/  (
+wch¬_t
+),
+
+389 
+__n
+, 
+__¡»am
+);
+
+391 ià((
+size_t
+è
+__n
+ > 
+	`__bos
+ (
+__s
+è/  (
+wch¬_t
+))
+
+392  
+	`__fg‘ws_chk_w¬n
+ (
+__s
+, 
+	`__bos
+ (__sè/  (
+wch¬_t
+),
+
+393 
+__n
+, 
+__¡»am
+);
+
+395  
+	`__fg‘ws_®Ÿs
+ (
+__s
+, 
+__n
+, 
+__¡»am
+);
+
+396 
+	}
+}
+
+398 #ifdeà
+__USE_GNU
+
+
+399 

+wch¬_t
+ *
+	$__fg‘ws_uÆocked_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+,
+
+400 
+__n
+, 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+)
+
+401 
+__wur
+;
+
+402 

+wch¬_t
+ *
+	`__REDIRECT
+ (
+__fg‘ws_uÆocked_®Ÿs
+,
+
+403 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+__n
+,
+
+404 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+), 
+fg‘ws_uÆocked
+)
+
+405 
+__wur
+;
+
+406 

+wch¬_t
+ *
+	`__REDIRECT
+ (
+__fg‘ws_uÆocked_chk_w¬n
+,
+
+407 (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__size
+, 
+__n
+,
+
+408 
+__FILE
+ *
+__»¡riù
+ 
+__¡»am
+),
+
+409 
+__fg‘ws_uÆocked_chk
+)
+
+410 
+__wur
+ 
+	`__w¬Ç‰r
+ ("fgetws_unlocked called with bigger size�han†ength "
+
+413 
+__ex‹º_®ways_šlše
+ 
+__wur
+ 
+wch¬_t
+ *
+
+414 
+	$fg‘ws_uÆocked
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__s
+, 
+__n
+, 
+__FILE
+ *__»¡riù 
+__¡»am
+)
+
+416 ià(
+	`__bos
+ (
+__s
+è!ð(
+size_t
+) -1)
+
+418 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__n
+) || __n <= 0)
+
+419  
+	`__fg‘ws_uÆocked_chk
+ (
+__s
+, 
+	`__bos
+ (__sè/  (
+wch¬_t
+),
+
+420 
+__n
+, 
+__¡»am
+);
+
+422 ià((
+size_t
+è
+__n
+ > 
+	`__bos
+ (
+__s
+è/  (
+wch¬_t
+))
+
+423  
+	`__fg‘ws_uÆocked_chk_w¬n
+ (
+__s
+, 
+	`__bos
+ (__sè/  (
+wch¬_t
+),
+
+424 
+__n
+, 
+__¡»am
+);
+
+426  
+	`__fg‘ws_uÆocked_®Ÿs
+ (
+__s
+, 
+__n
+, 
+__¡»am
+);
+
+427 
+	}
+}
+
+431 

+size_t
+ 
+	$__wütomb_chk
+ (*
+__s
+, 
+wch¬_t
+ 
+__wch¬
+, 
+mb¡©e_t
+ *
+__p
+,
+
+432 
+size_t
+ 
+__buæ’
+è
+__THROW
+ 
+__wur
+;
+
+433 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__wütomb_®Ÿs
+,
+
+434 (*
+__»¡riù
+ 
+__s
+, 
+wch¬_t
+ 
+__wch¬
+,
+
+435 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+), 
+wütomb
+è
+__wur
+;
+
+437 
+__ex‹º_®ways_šlše
+ 
+__wur
+ 
+size_t
+
+
+438 
+	`__NTH
+ (
+	$wütomb
+ (*
+__s
+, 
+wch¬_t
+ 
+__wch¬
+, 
+mb¡©e_t
+ *
+__ps
+))
+
+443 

+	#__WCHAR_MB_LEN_MAX
+ 16
+
+	)
+
+444 #ià
+defšed
+ 
+MB_LEN_MAX
+ && MB_LEN_MAX !ð
+__WCHAR_MB_LEN_MAX
+
+
+447 ià(
+	`__bos
+ (
+__s
+è!ð(
+size_t
+è-1 && 
+__WCHAR_MB_LEN_MAX
+ > __bos (__s))
+
+448  
+	`__wütomb_chk
+ (
+__s
+, 
+__wch¬
+, 
+__ps
+, 
+	`__bos
+ (__s));
+
+449  
+	`__wütomb_®Ÿs
+ (
+__s
+, 
+__wch¬
+, 
+__ps
+);
+
+450 
+	}
+}
+
+453 

+size_t
+ 
+	$__mb¤towcs_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+454 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+,
+
+455 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+456 
+size_t
+ 
+__d¡Ën
+è
+__THROW
+;
+
+457 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__mb¤towcs_®Ÿs
+,
+
+458 (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+459 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+,
+
+460 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+),
+
+461 
+mb¤towcs
+);
+
+462 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__mb¤towcs_chk_w¬n
+,
+
+463 (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+464 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+,
+
+465 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+466 
+size_t
+ 
+__d¡Ën
+), 
+__mb¤towcs_chk
+)
+
+467 
+	`__w¬Ç‰r
+ ("mbsrtowcs called with dst buffer smaller�han†en "
+
+470 
+__ex‹º_®ways_šlše
+ 
+size_t
+
+
+471 
+	`__NTH
+ (
+	$mb¤towcs
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+, 
+__cÚ¡
+ **__»¡riù 
+__¤c
+,
+
+472 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+))
+
+474 ià(
+	`__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+476 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__Ën
+))
+
+477  
+	`__mb¤towcs_chk
+ (
+__d¡
+, 
+__¤c
+, 
+__Ën
+, 
+__ps
+,
+
+478 
+	`__bos
+ (
+__d¡
+è/  (
+wch¬_t
+));
+
+480 ià(
+__Ën
+ > 
+	`__bos
+ (
+__d¡
+è/  (
+wch¬_t
+))
+
+481  
+	`__mb¤towcs_chk_w¬n
+ (
+__d¡
+, 
+__¤c
+, 
+__Ën
+, 
+__ps
+,
+
+482 
+	`__bos
+ (
+__d¡
+è/  (
+wch¬_t
+));
+
+484  
+	`__mb¤towcs_®Ÿs
+ (
+__d¡
+, 
+__¤c
+, 
+__Ën
+, 
+__ps
+);
+
+485 
+	}
+}
+
+488 

+size_t
+ 
+	$__wc¤tombs_chk
+ (*
+__»¡riù
+ 
+__d¡
+,
+
+489 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+490 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+491 
+size_t
+ 
+__d¡Ën
+è
+__THROW
+;
+
+492 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__wc¤tombs_®Ÿs
+,
+
+493 (*
+__»¡riù
+ 
+__d¡
+,
+
+494 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+495 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+),
+
+496 
+wc¤tombs
+);
+
+497 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__wc¤tombs_chk_w¬n
+,
+
+498 (*
+__»¡riù
+ 
+__d¡
+,
+
+499 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+500 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+501 
+size_t
+ 
+__d¡Ën
+), 
+__wc¤tombs_chk
+)
+
+502 
+	`__w¬Ç‰r
+ ("wcsrtombs called with dst buffer smaller�han†en");
+
+504 
+__ex‹º_®ways_šlše
+ 
+size_t
+
+
+505 
+	`__NTH
+ (
+	$wc¤tombs
+ (*
+__»¡riù
+ 
+__d¡
+, 
+__cÚ¡
+ 
+wch¬_t
+ **__»¡riù 
+__¤c
+,
+
+506 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+))
+
+508 ià(
+	`__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+510 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__Ën
+))
+
+511  
+	`__wc¤tombs_chk
+ (
+__d¡
+, 
+__¤c
+, 
+__Ën
+, 
+__ps
+, 
+	`__bos
+ (__dst));
+
+513 ià(
+__Ën
+ > 
+	`__bos
+ (
+__d¡
+))
+
+514  
+	`__wc¤tombs_chk_w¬n
+ (
+__d¡
+, 
+__¤c
+, 
+__Ën
+, 
+__ps
+, 
+	`__bos
+ (__dst));
+
+516  
+	`__wc¤tombs_®Ÿs
+ (
+__d¡
+, 
+__¤c
+, 
+__Ën
+, 
+__ps
+);
+
+517 
+	}
+}
+
+520 #ifdeà
+__USE_GNU
+
+
+521 

+size_t
+ 
+	$__mb¢¹owcs_chk
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+522 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__nmc
+,
+
+523 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+524 
+size_t
+ 
+__d¡Ën
+è
+__THROW
+;
+
+525 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__mb¢¹owcs_®Ÿs
+,
+
+526 (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+527 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__nmc
+,
+
+528 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+),
+
+529 
+mb¢¹owcs
+);
+
+530 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__mb¢¹owcs_chk_w¬n
+,
+
+531 (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+,
+
+532 
+__cÚ¡
+ **
+__»¡riù
+ 
+__¤c
+, 
+size_t
+ 
+__nmc
+,
+
+533 
+size_t
+ 
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+534 
+size_t
+ 
+__d¡Ën
+), 
+__mb¢¹owcs_chk
+)
+
+535 
+	`__w¬Ç‰r
+ ("mbsnrtowcs called with dst buffer smaller�han†en "
+
+538 
+__ex‹º_®ways_šlše
+ 
+size_t
+
+
+539 
+	`__NTH
+ (
+	$mb¢¹owcs
+ (
+wch¬_t
+ *
+__»¡riù
+ 
+__d¡
+, 
+__cÚ¡
+ **__»¡riù 
+__¤c
+,
+
+540 
+size_t
+ 
+__nmc
+, size_ˆ
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+))
+
+542 ià(
+	`__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+544 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__Ën
+))
+
+545  
+	`__mb¢¹owcs_chk
+ (
+__d¡
+, 
+__¤c
+, 
+__nmc
+, 
+__Ën
+, 
+__ps
+,
+
+546 
+	`__bos
+ (
+__d¡
+è/  (
+wch¬_t
+));
+
+548 ià(
+__Ën
+ > 
+	`__bos
+ (
+__d¡
+è/  (
+wch¬_t
+))
+
+549  
+	`__mb¢¹owcs_chk_w¬n
+ (
+__d¡
+, 
+__¤c
+, 
+__nmc
+, 
+__Ën
+, 
+__ps
+,
+
+550 
+	`__bos
+ (
+__d¡
+è/  (
+wch¬_t
+));
+
+552  
+	`__mb¢¹owcs_®Ÿs
+ (
+__d¡
+, 
+__¤c
+, 
+__nmc
+, 
+__Ën
+, 
+__ps
+);
+
+553 
+	}
+}
+
+556 

+size_t
+ 
+	$__wc¢¹ombs_chk
+ (*
+__»¡riù
+ 
+__d¡
+,
+
+557 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+558 
+size_t
+ 
+__nwc
+, size_ˆ
+__Ën
+,
+
+559 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+, 
+size_t
+ 
+__d¡Ën
+)
+
+560 
+__THROW
+;
+
+561 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__wc¢¹ombs_®Ÿs
+,
+
+562 (*
+__»¡riù
+ 
+__d¡
+,
+
+563 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+564 
+size_t
+ 
+__nwc
+, size_ˆ
+__Ën
+,
+
+565 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+), 
+wc¢¹ombs
+);
+
+566 

+size_t
+ 
+	`__REDIRECT_NTH
+ (
+__wc¢¹ombs_chk_w¬n
+,
+
+567 (*
+__»¡riù
+ 
+__d¡
+,
+
+568 
+__cÚ¡
+ 
+wch¬_t
+ **
+__»¡riù
+ 
+__¤c
+,
+
+569 
+size_t
+ 
+__nwc
+, size_ˆ
+__Ën
+,
+
+570 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+,
+
+571 
+size_t
+ 
+__d¡Ën
+), 
+__wc¢¹ombs_chk
+)
+
+572 
+	`__w¬Ç‰r
+ ("wcsnrtombs called with dst buffer smaller�han†en");
+
+574 
+__ex‹º_®ways_šlše
+ 
+size_t
+
+
+575 
+	`__NTH
+ (
+	$wc¢¹ombs
+ (*
+__»¡riù
+ 
+__d¡
+, 
+__cÚ¡
+ 
+wch¬_t
+ **__»¡riù 
+__¤c
+,
+
+576 
+size_t
+ 
+__nwc
+, size_ˆ
+__Ën
+, 
+mb¡©e_t
+ *
+__»¡riù
+ 
+__ps
+))
+
+578 ià(
+	`__bos
+ (
+__d¡
+è!ð(
+size_t
+) -1)
+
+580 ià(!
+	`__bužtš_cÚ¡ªt_p
+ (
+__Ën
+))
+
+581  
+	`__wc¢¹ombs_chk
+ (
+__d¡
+, 
+__¤c
+, 
+__nwc
+, 
+__Ën
+, 
+__ps
+,
+
+582 
+	`__bos
+ (
+__d¡
+));
+
+584 ià(
+__Ën
+ > 
+	`__bos
+ (
+__d¡
+))
+
+585  
+	`__wc¢¹ombs_chk_w¬n
+ (
+__d¡
+, 
+__¤c
+, 
+__nwc
+, 
+__Ën
+, 
+__ps
+,
+
+586 
+	`__bos
+ (
+__d¡
+));
+
+588  
+	`__wc¢¹ombs_®Ÿs
+ (
+__d¡
+, 
+__¤c
+, 
+__nwc
+, 
+__Ën
+, 
+__ps
+);
+
+589 
+	}
+}
+
+	@/usr/include/errno.h
+
+23 #iâdef 
+_ERRNO_H
+
+
+27 #iâdef 
+__Ãed_Em©h
+
+
+28 

+	#_ERRNO_H
+ 1
+
+	)
+
+29 
+	~<ã©u»s.h
+>
+
+32 
+	g__BEGIN_DECLS
+
+
+36 
+	~<b™s/”ºo.h
+>
+
+37 #undeà
+__Ãed_Em©h
+
+
+39 #ifdef 
+_ERRNO_H
+
+
+46 #iâdef 
+Ӽo
+
+
+47 

+Ӽo
+;
+
+50 #ifdeà
+__USE_GNU
+
+
+55 
*
+´og¿m_švoÿtiÚ_Çme
+, *
+´og¿m_švoÿtiÚ_shÜt_Çme
+;
+
+59 
+	g__END_DECLS
+
+
+67 #ià
+defšed
+ 
+__USE_GNU
+ || defšed 
+__Ãed_”rÜ_t
+
+
+68 #iâdeà
+__”rÜ_t_defšed
+
+
+69 
+	t”rÜ_t
+;
+
+70 

+	#__”rÜ_t_defšed
+ 1
+
+	)
+
+72 #undeà
+__Ãed_”rÜ_t
+
+
+	@/usr/include/gnu/option-groups.h
+
+10 #iâdeà
+__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 #iâdeà
+_PTHREAD_H
+
+
+21 

+	#_PTHREAD_H
+ 1
+
+	)
+
+23 
+	~<ã©u»s.h
+>
+
+24 
+	~<’dŸn.h
+>
+
+25 
+	~<sched.h
+>
+
+26 
+	~<time.h
+>
+
+28 

+	#__Ãed_sig£t_t
+
+
+	)
+
+29 
+	~<sigÇl.h
+>
+
+30 
+	~<b™s/±h»adty³s.h
+>
+
+31 
+	~<b™s/£tjmp.h
+>
+
+32 
+	~<b™s/wÜdsize.h
+>
+
+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à
+defšed
+ 
+__USE_UNIX98
+ || defšed 
+__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_±h»ad_þ—nup_bufãr
+
+
+186 (*
+	m__routše
+) (*);
+
+187 *
+	m__¬g
+;
+
+188 
+	m__ÿnûÉy³
+;
+
+189 
+_±h»ad_þ—nup_bufãr
+ *
+	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 

+±h»ad_ü—‹
+ (
+±h»ad_t
+ *
+__»¡riù
+ 
+__Ãwth»ad
+,
+
+228 
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+ 
+__©Œ
+,
+
+229 *(*
+__¡¬t_routše
+) (*),
+
+230 *
+__»¡riù
+ 
+__¬g
+è
+__THROW
+ 
+__nÚnuÎ
+ ((1, 3));
+
+236 

+	$±h»ad_ex™
+ (*
+__»tv®
+è
+	`__©Œibu‹__
+ ((
+__nÜ‘uº__
+));
+
+244 

+	`±h»ad_još
+ (
+±h»ad_t
+ 
+__th
+, **
+__th»ad_»tuº
+);
+
+246 #ifdeà
+__USE_GNU
+
+
+249 

+	$±h»ad_Œyjoš_Å
+ (
+±h»ad_t
+ 
+__th
+, **
+__th»ad_»tuº
+è
+__THROW
+;
+
+257 

+	`±h»ad_timedjoš_Å
+ (
+±h»ad_t
+ 
+__th
+, **
+__th»ad_»tuº
+,
+
+258 
+__cÚ¡
+ 
+time¥ec
+ *
+__ab¡ime
+);
+
+265 

+	$±h»ad_d‘ach
+ (
+±h»ad_t
+ 
+__th
+è
+__THROW
+;
+
+269 

+±h»ad_t
+ 
+	$±h»ad_£lf
+ (è
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡__
+));
+
+272 

+	$±h»ad_equ®
+ (
+±h»ad_t
+ 
+__th»ad1
+,…th»ad_ˆ
+__th»ad2
+è
+__THROW
+;
+
+280 

+	$±h»ad_©Œ_š™
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+283 

+	$±h»ad_©Œ_de¡roy
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+)
+
+284 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+287 

+	$±h»ad_©Œ_g‘d‘ach¡©e
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+288 *
+__d‘ach¡©e
+)
+
+289 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+292 

+	$±h»ad_©Œ_£td‘ach¡©e
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+293 
+__d‘ach¡©e
+)
+
+294 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+298 

+	$±h»ad_©Œ_g‘gu¬dsize
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+299 
+size_t
+ *
+__gu¬dsize
+)
+
+300 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+303 

+	$±h»ad_©Œ_£tgu¬dsize
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+304 
+size_t
+ 
+__gu¬dsize
+)
+
+305 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+309 

+	$±h»ad_©Œ_g‘sched·¿m
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+
+
+310 
+__©Œ
+,
+
+311 
+sched_·¿m
+ *
+__»¡riù
+ 
+__·¿m
+)
+
+312 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+315 

+	$±h»ad_©Œ_£tsched·¿m
+ (
+±h»ad_©Œ_t
+ *
+__»¡riù
+ 
+__©Œ
+,
+
+316 
+__cÚ¡
+ 
+sched_·¿m
+ *
+__»¡riù
+
+
+317 
+__·¿m
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+320 

+	$±h»ad_©Œ_g‘schedpÞicy
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+
+
+321 
+__©Œ
+, *
+__»¡riù
+ 
+__pÞicy
+)
+
+322 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+325 

+	$±h»ad_©Œ_£tschedpÞicy
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+, 
+__pÞicy
+)
+
+326 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+329 

+	$±h»ad_©Œ_g‘šh”™sched
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+
+
+330 
+__©Œ
+, *
+__»¡riù
+ 
+__šh”™
+)
+
+331 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+334 

+	$±h»ad_©Œ_£tšh”™sched
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+335 
+__šh”™
+)
+
+336 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+340 

+	$±h»ad_©Œ_g‘scÝe
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+ 
+__©Œ
+,
+
+341 *
+__»¡riù
+ 
+__scÝe
+)
+
+342 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+345 

+	$±h»ad_©Œ_£tscÝe
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+, 
+__scÝe
+)
+
+346 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+349 

+	$±h»ad_©Œ_g‘¡ackaddr
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+
+
+350 
+__©Œ
+, **
+__»¡riù
+ 
+__¡ackaddr
+)
+
+351 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2)è
+__©Œibu‹_d•»ÿ‹d__
+;
+
+357 

+	$±h»ad_©Œ_£t¡ackaddr
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+358 *
+__¡ackaddr
+)
+
+359 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1)è
+__©Œibu‹_d•»ÿ‹d__
+;
+
+362 

+	$±h»ad_©Œ_g‘¡acksize
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+
+
+363 
+__©Œ
+, 
+size_t
+ *
+__»¡riù
+ 
+__¡acksize
+)
+
+364 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+369 

+	$±h»ad_©Œ_£t¡acksize
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+370 
+size_t
+ 
+__¡acksize
+)
+
+371 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+373 #ifdeà
+__USE_XOPEN2K
+
+
+375 

+	$±h»ad_©Œ_g‘¡ack
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__»¡riù
+ 
+__©Œ
+,
+
+376 **
+__»¡riù
+ 
+__¡ackaddr
+,
+
+377 
+size_t
+ *
+__»¡riù
+ 
+__¡acksize
+)
+
+378 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2, 3));
+
+383 

+	$±h»ad_©Œ_£t¡ack
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+, *
+__¡ackaddr
+,
+
+384 
+size_t
+ 
+__¡acksize
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+387 #ifdeà
+__USE_GNU
+
+
+390 

+	$±h»ad_©Œ_£�ffš™y_Å
+ (
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+391 
+size_t
+ 
+__ýu£tsize
+,
+
+392 
+__cÚ¡
+ 
+ýu_£t_t
+ *
+__ýu£t
+)
+
+393 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 3));
+
+397 

+	$±h»ad_©Œ_g‘affš™y_Å
+ (
+__cÚ¡
+ 
+±h»ad_©Œ_t
+ *
+__©Œ
+,
+
+398 
+size_t
+ 
+__ýu£tsize
+,
+
+399 
+ýu_£t_t
+ *
+__ýu£t
+)
+
+400 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 3));
+
+406 

+	$±h»ad_g‘©Œ_Å
+ (
+±h»ad_t
+ 
+__th
+, 
+±h»ad_©Œ_t
+ *
+__©Œ
+)
+
+407 
+__THROW
+ 
+	`__nÚnuÎ
+ ((2));
+
+415 

+	$±h»ad_£tsched·¿m
+ (
+±h»ad_t
+ 
+__�rg‘_th»ad
+, 
+__pÞicy
+,
+
+416 
+__cÚ¡
+ 
+sched_·¿m
+ *
+__·¿m
+)
+
+417 
+__THROW
+ 
+	`__nÚnuÎ
+ ((3));
+
+420 

+	$±h»ad_g‘sched·¿m
+ (
+±h»ad_t
+ 
+__�rg‘_th»ad
+,
+
+421 *
+__»¡riù
+ 
+__pÞicy
+,
+
+422 
+sched_·¿m
+ *
+__»¡riù
+ 
+__·¿m
+)
+
+423 
+__THROW
+ 
+	`__nÚnuÎ
+ ((2, 3));
+
+426 

+	$±h»ad_£tsched´io
+ (
+±h»ad_t
+ 
+__�rg‘_th»ad
+, 
+__´io
+)
+
+427 
+__THROW
+;
+
+430 #ifdeà
+__USE_UNIX98
+
+
+432 

+	$±h»ad_g‘cÚcu¼’cy
+ (è
+__THROW
+;
+
+435 

+	$±h»ad_£tcÚcu¼’cy
+ (
+__Ëv–
+è
+__THROW
+;
+
+438 #ifdeà
+__USE_GNU
+
+
+443 

+	$±h»ad_y›ld
+ (è
+__THROW
+;
+
+448 

+	$±h»ad_£�ffš™y_Å
+ (
+±h»ad_t
+ 
+__th
+, 
+size_t
+ 
+__ýu£tsize
+,
+
+449 
+__cÚ¡
+ 
+ýu_£t_t
+ *
+__ýu£t
+)
+
+450 
+__THROW
+ 
+	`__nÚnuÎ
+ ((3));
+
+453 

+	$±h»ad_g‘affš™y_Å
+ (
+±h»ad_t
+ 
+__th
+, 
+size_t
+ 
+__ýu£tsize
+,
+
+454 
+ýu_£t_t
+ *
+__ýu£t
+)
+
+455 
+__THROW
+ 
+	`__nÚnuÎ
+ ((3));
+
+468 

+	`±h»ad_Úû
+ (
+±h»ad_Úû_t
+ *
+__Úû_cÚŒÞ
+,
+
+469 (*
+__š™_routše
+è()è
+	`__nÚnuÎ
+ ((1, 2));
+
+480 

+	`±h»ad_£tÿnûl¡©e
+ (
+__¡©e
+, *
+__Þd¡©e
+);
+
+484 

+	`±h»ad_£tÿnûÉy³
+ (
+__ty³
+, *
+__Þdty³
+);
+
+487 

+	`±h»ad_ÿnûl
+ (
+±h»ad_t
+ 
+__th
+);
+
+492 

+	`±h»ad_‹¡ÿnûl
+ ();
+
+501 
+__jmp_buf
+ 
+__ÿnûl_jmp_buf
+;
+
+502 
+__mask_was_§ved
+;
+
+503 } 
+__ÿnûl_jmp_buf
+[1];
+
+504 *
+__·d
+[4];
+
+505 } 
+	t__±h»ad_unwšd_buf_t
+ 
+	t__©Œibu‹__
+ ((
+	t__®igÃd__
+));
+
+508 #iâdeà
+__þ—nup_fù_©Œibu‹
+
+
+509 

+	#__þ—nup_fù_©Œibu‹
+
+
+	)
+
+514 
+	s__±h»ad_þ—nup_äame
+
+
+516 (*
+__ÿnûl_routše
+) (*);
+
+517 *
+__ÿnûl_¬g
+;
+
+518 
+__do_™
+;
+
+519 
+__ÿnûl_ty³
+;
+
+522 #ià
+defšed
+ 
+__GNUC__
+ && defšed 
+__EXCEPTIONS
+
+
+523 #ifdeà
+__ýlu¥lus
+
+
+525 þas 
+	c__±h»ad_þ—nup_þass
+
+
+527 (*
+__ÿnûl_routše
+) (*);
+
+528 *
+__ÿnûl_¬g
+;
+
+529 
+__do_™
+;
+
+530 
+__ÿnûl_ty³
+;
+
+532 
+public
+:
+
+533 
+	`__±h»ad_þ—nup_þass
+ ((*
+__fù
+è(*), *
+__¬g
+)
+
+534 : 
+	`__ÿnûl_routše
+ (
+__fù
+), 
+	`__ÿnûl_¬g
+ (
+__¬g
+), 
+	$__do_™
+ (1) { }
+
+535 ~
+	$__±h»ad_þ—nup_þass
+ (è{ ià(
+__do_™
+è
+	`__ÿnûl_routše
+ (
+__ÿnûl_¬g
+); 
+	}
+}
+
+536 
+	$__£tdo™
+ (
+__Ãwv®
+è{ 
+__do_™
+ = __Ãwv®; 
+	}
+}
+
+537 
+	$__deãr
+ (è{ 
+	`±h»ad_£tÿnûÉy³
+ (
+PTHREAD_CANCEL_DEFERRED
+,
+
+538 &
+__ÿnûl_ty³
+); 
+	}
+}
+
+539 
+	$__»¡Üe
+ (ècÚ¡ { 
+	`±h»ad_£tÿnûÉy³
+ (
+__ÿnûl_ty³
+, 0); 
+	}
+}
+
+549 

+	#±h»ad_þ—nup_push
+(
+routše
+, 
+¬g
+) \
+
+551 
+__±h»ad_þ—nup_þass
+ 
+	`__þäame
+ (
+routše
+, 
+¬g
+)
+
+	)
+
+555 

+	#±h»ad_þ—nup_pÝ
+(
+execu‹
+) \
+
+556 
+__þäame
+.
+	`__£tdo™
+ (
+execu‹
+); \
+
+557 } 0)
+
+	)
+
+559 #ifdeà
+__USE_GNU
+
+
+563 

+	#±h»ad_þ—nup_push_deãr_Å
+(
+routše
+, 
+¬g
+) \
+
+565 
+__±h»ad_þ—nup_þass
+ 
+	`__þäame
+ (
+routše
+, 
+¬g
+); \
+
+566 
+__þäame
+.
+	`__deãr
+ ()
+
+	)
+
+571 

+	#±h»ad_þ—nup_pÝ_»¡Üe_Å
+(
+execu‹
+) \
+
+572 
+__þäame
+.
+	`__»¡Üe
+ (); \
+
+573 
+__þäame
+.
+	`__£tdo™
+ (
+execu‹
+); \
+
+574 } 0)
+
+	)
+
+581 
+__ex‹º_šlše
+ 
+
+582 
+	$__±h»ad_þ—nup_routše
+ (
+__±h»ad_þ—nup_äame
+ *
+__äame
+)
+
+584 ià(
+__äame
+->
+__do_™
+)
+
+585 
+__äame
+->
+	`__ÿnûl_routše
+ (__äame->
+__ÿnûl_¬g
+);
+
+586 
+	}
+}
+
+595 

+	#±h»ad_þ—nup_push
+(
+routše
+, 
+¬g
+) \
+
+597 
+__±h»ad_þ—nup_äame
+ 
+__þäame
+ \
+
+598 
+	`__©Œibu‹__
+ ((
+	`__þ—nup__
+ (
+__±h»ad_þ—nup_routše
+))) \
+
+599 ð{ .
+__ÿnûl_routše
+ = (
+routše
+), .
+__ÿnûl_¬g
+ = (
+¬g
+), \
+
+600 .
+__do_™
+ = 1 };
+
+	)
+
+604 

+	#±h»ad_þ—nup_pÝ
+(
+execu‹
+) \
+
+605 
+__þäame
+.
+__do_™
+ = (
+execu‹
+); \
+
+606 } 0)
+
+	)
+
+608 #ifdeà
+__USE_GNU
+
+
+612 

+	#±h»ad_þ—nup_push_deãr_Å
+(
+routše
+, 
+¬g
+) \
+
+614 
+__±h»ad_þ—nup_äame
+ 
+__þäame
+ \
+
+615 
+	`__©Œibu‹__
+ ((
+	`__þ—nup__
+ (
+__±h»ad_þ—nup_routše
+))) \
+
+616 ð{ .
+__ÿnûl_routše
+ = (
+routše
+), .
+__ÿnûl_¬g
+ = (
+¬g
+), \
+
+617 .
+__do_™
+ = 1 }; \
+
+618 (è
+	`±h»ad_£tÿnûÉy³
+ (
+PTHREAD_CANCEL_DEFERRED
+, \
+
+619 &
+__þäame
+.
+__ÿnûl_ty³
+)
+
+	)
+
+624 

+	#±h»ad_þ—nup_pÝ_»¡Üe_Å
+(
+execu‹
+) \
+
+625 (è
+	`±h»ad_£tÿnûÉy³
+ (
+__þäame
+.
+__ÿnûl_ty³
+, 
+NULL
+); \
+
+626 
+__þäame
+.
+__do_™
+ = (
+execu‹
+); \
+
+627 } 0)
+
+	)
+
+638 

+	#±h»ad_þ—nup_push
+(
+routše
+, 
+¬g
+) \
+
+640 
+__±h»ad_unwšd_buf_t
+ 
+__ÿnûl_buf
+; \
+
+641 (*
+__ÿnûl_routše
+è(*èð(
+routše
+); \
+
+642 *
+__ÿnûl_¬g
+ = (
+¬g
+); \
+
+643 
+nÙ_fœ¡_ÿÎ
+ = 
+	`__sig£tjmp
+ ((
+__jmp_buf_�g
+ *) (*) \
+
+644 
+__ÿnûl_buf
+.
+__ÿnûl_jmp_buf
+, 0); \
+
+645 ià(
+	`__bužtš_ex³ù
+ (
+nÙ_fœ¡_ÿÎ
+, 0)) \
+
+647 
+	`__ÿnûl_routše
+ (
+__ÿnûl_¬g
+); \
+
+648 
+	`__±h»ad_unwšd_Ãxt
+ (&
+__ÿnûl_buf
+); \
+
+652 
+	`__±h»ad_»gi¡”_ÿnûl
+ (&
+__ÿnûl_buf
+); \
+
+653 dØ{
+
+	)
+
+654 

+__±h»ad_»gi¡”_ÿnûl
+ (
+__±h»ad_unwšd_buf_t
+ *
+__buf
+)
+
+655 
+__þ—nup_fù_©Œibu‹
+;
+
+659 

+	#±h»ad_þ—nup_pÝ
+(
+execu‹
+) \
+
+662 
+	`__±h»ad_uÄegi¡”_ÿnûl
+ (&
+__ÿnûl_buf
+); \
+
+663 ià(
+execu‹
+) \
+
+664 
+	`__ÿnûl_routše
+ (
+__ÿnûl_¬g
+); \
+
+665 } 0)
+
+	)
+
+666 

+	$__±h»ad_uÄegi¡”_ÿnûl
+ (
+__±h»ad_unwšd_buf_t
+ *
+__buf
+)
+
+667 
+__þ—nup_fù_©Œibu‹
+;
+
+669 #ifdeà
+__USE_GNU
+
+
+673 

+	#±h»ad_þ—nup_push_deãr_Å
+(
+routše
+, 
+¬g
+) \
+
+675 
+__±h»ad_unwšd_buf_t
+ 
+__ÿnûl_buf
+; \
+
+676 (*
+__ÿnûl_routše
+è(*èð(
+routše
+); \
+
+677 *
+__ÿnûl_¬g
+ = (
+¬g
+); \
+
+678 
+nÙ_fœ¡_ÿÎ
+ = 
+	`__sig£tjmp
+ ((
+__jmp_buf_�g
+ *) (*) \
+
+679 
+__ÿnûl_buf
+.
+__ÿnûl_jmp_buf
+, 0); \
+
+680 ià(
+	`__bužtš_ex³ù
+ (
+nÙ_fœ¡_ÿÎ
+, 0)) \
+
+682 
+	`__ÿnûl_routše
+ (
+__ÿnûl_¬g
+); \
+
+683 
+	`__±h»ad_unwšd_Ãxt
+ (&
+__ÿnûl_buf
+); \
+
+687 
+	`__±h»ad_»gi¡”_ÿnûl_deãr
+ (&
+__ÿnûl_buf
+); \
+
+688 dØ{
+
+	)
+
+689 

+	`__±h»ad_»gi¡”_ÿnûl_deãr
+ (
+__±h»ad_unwšd_buf_t
+ *
+__buf
+)
+
+690 
+__þ—nup_fù_©Œibu‹
+;
+
+695 

+	#±h»ad_þ—nup_pÝ_»¡Üe_Å
+(
+execu‹
+) \
+
+698 
+	`__±h»ad_uÄegi¡”_ÿnûl_»¡Üe
+ (&
+__ÿnûl_buf
+); \
+
+699 ià(
+execu‹
+) \
+
+700 
+	`__ÿnûl_routše
+ (
+__ÿnûl_¬g
+); \
+
+701 
+	}
+} 0)
+
+	)
+
+702 

+	$__±h»ad_uÄegi¡”_ÿnûl_»¡Üe
+ (
+__±h»ad_unwšd_buf_t
+ *
+__buf
+)
+
+703 
+__þ—nup_fù_©Œibu‹
+;
+
+707 

+	$__±h»ad_unwšd_Ãxt
+ (
+__±h»ad_unwšd_buf_t
+ *
+__buf
+)
+
+708 
+__þ—nup_fù_©Œibu‹
+ 
+	`__©Œibu‹__
+ ((
+__nÜ‘uº__
+))
+
+709 #iâdeà
+SHARED
+
+
+710 
+	`__©Œibu‹__
+ ((
+__w—k__
+))
+
+716 
+__jmp_buf_�g
+;
+
+717 

+	$__sig£tjmp
+ (
+__jmp_buf_�g
+ *
+__’v
+, 
+__§vemask
+è
+__THROW
+;
+
+723 

+	$±h»ad_mu‹x_š™
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+,
+
+724 
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+__mu‹x©Œ
+)
+
+725 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+728 

+	$±h»ad_mu‹x_de¡roy
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+)
+
+729 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+732 

+	$±h»ad_mu‹x_Œylock
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+)
+
+733 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+736 

+	$±h»ad_mu‹x_lock
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+)
+
+737 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+739 #ifdeà
+__USE_XOPEN2K
+
+
+741 

+	$±h»ad_mu‹x_timedlock
+ (
+±h»ad_mu‹x_t
+ *
+__»¡riù
+ 
+__mu‹x
+,
+
+742 
+__cÚ¡
+ 
+time¥ec
+ *
+__»¡riù
+
+
+743 
+__ab¡ime
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+747 

+	$±h»ad_mu‹x_uÆock
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+)
+
+748 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+751 #ifdeà
+__USE_UNIX98
+
+
+753 

+	$±h»ad_mu‹x_g‘´ioûžšg
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x_t
+ *
+
+754 
+__»¡riù
+ 
+__mu‹x
+,
+
+755 *
+__»¡riù
+ 
+__´ioûžšg
+)
+
+756 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+760 

+	$±h»ad_mu‹x_£�rioûžšg
+ (
+±h»ad_mu‹x_t
+ *
+__»¡riù
+ 
+__mu‹x
+,
+
+761 
+__´ioûžšg
+,
+
+762 *
+__»¡riù
+ 
+__Þd_ûžšg
+)
+
+763 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 3));
+
+767 #ifdeà
+__USE_XOPEN2K8
+
+
+769 

+	$±h»ad_mu‹x_cÚsi¡’t_Å
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+)
+
+770 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+771 #ifdeà
+__USE_GNU
+
+
+772 

+	$±h»ad_mu‹x_cÚsi¡’t_Å
+ (
+±h»ad_mu‹x_t
+ *
+__mu‹x
+)
+
+773 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+782 

+	$±h»ad_mu‹x©Œ_š™
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+)
+
+783 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+786 

+	$±h»ad_mu‹x©Œ_de¡roy
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+)
+
+787 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+790 

+	$±h»ad_mu‹x©Œ_g‘psh¬ed
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+
+791 
+__»¡riù
+ 
+__©Œ
+,
+
+792 *
+__»¡riù
+ 
+__psh¬ed
+)
+
+793 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+796 

+	$±h»ad_mu‹x©Œ_£�sh¬ed
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+797 
+__psh¬ed
+)
+
+798 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+800 #ifdeà
+__USE_UNIX98
+
+
+802 

+	$±h»ad_mu‹x©Œ_g‘ty³
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+__»¡riù
+
+
+803 
+__©Œ
+, *
+__»¡riù
+ 
+__kšd
+)
+
+804 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+809 

+	$±h»ad_mu‹x©Œ_£‰y³
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+, 
+__kšd
+)
+
+810 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+813 

+	$±h»ad_mu‹x©Œ_g‘´ÙocÞ
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+
+814 
+__»¡riù
+ 
+__©Œ
+,
+
+815 *
+__»¡riù
+ 
+__´ÙocÞ
+)
+
+816 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+820 

+	$±h»ad_mu‹x©Œ_£�rÙocÞ
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+821 
+__´ÙocÞ
+)
+
+822 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+825 

+	$±h»ad_mu‹x©Œ_g‘´ioûžšg
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+
+826 
+__»¡riù
+ 
+__©Œ
+,
+
+827 *
+__»¡riù
+ 
+__´ioûžšg
+)
+
+828 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+831 

+	$±h»ad_mu‹x©Œ_£�rioûžšg
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+832 
+__´ioûžšg
+)
+
+833 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+836 #ifdeà
+__USE_XOPEN2K
+
+
+838 

+	$±h»ad_mu‹x©Œ_g‘robu¡
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+839 *
+__robu¡Ãss
+)
+
+840 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+841 #ifdeà
+__USE_GNU
+
+
+842 

+	$±h»ad_mu‹x©Œ_g‘robu¡_Å
+ (
+__cÚ¡
+ 
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+843 *
+__robu¡Ãss
+)
+
+844 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+848 

+	$±h»ad_mu‹x©Œ_£Œobu¡
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+849 
+__robu¡Ãss
+)
+
+850 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+851 #ifdeà
+__USE_GNU
+
+
+852 

+	$±h»ad_mu‹x©Œ_£Œobu¡_Å
+ (
+±h»ad_mu‹x©Œ_t
+ *
+__©Œ
+,
+
+853 
+__robu¡Ãss
+)
+
+854 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+859 #ià
+defšed
+ 
+__USE_UNIX98
+ || defšed 
+__USE_XOPEN2K
+
+
+864 

+	$±h»ad_rwlock_š™
+ (
+±h»ad_rwlock_t
+ *
+__»¡riù
+ 
+__rwlock
+,
+
+865 
+__cÚ¡
+ 
+±h»ad_rwlock©Œ_t
+ *
+__»¡riù
+
+
+866 
+__©Œ
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+869 

+	$±h»ad_rwlock_de¡roy
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+870 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+873 

+	$±h»ad_rwlock_rdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+874 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+877 

+	$±h»ad_rwlock_Œyrdlock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+878 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+880 #ifdeà
+__USE_XOPEN2K
+
+
+882 

+	$±h»ad_rwlock_timedrdlock
+ (
+±h»ad_rwlock_t
+ *
+__»¡riù
+ 
+__rwlock
+,
+
+883 
+__cÚ¡
+ 
+time¥ec
+ *
+__»¡riù
+
+
+884 
+__ab¡ime
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+888 

+	$±h»ad_rwlock_w¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+889 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+892 

+	$±h»ad_rwlock_Œyw¾ock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+893 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+895 #ifdeà
+__USE_XOPEN2K
+
+
+897 

+	$±h»ad_rwlock_timedw¾ock
+ (
+±h»ad_rwlock_t
+ *
+__»¡riù
+ 
+__rwlock
+,
+
+898 
+__cÚ¡
+ 
+time¥ec
+ *
+__»¡riù
+
+
+899 
+__ab¡ime
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+903 

+	$±h»ad_rwlock_uÆock
+ (
+±h»ad_rwlock_t
+ *
+__rwlock
+)
+
+904 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+910 

+	$±h»ad_rwlock©Œ_š™
+ (
+±h»ad_rwlock©Œ_t
+ *
+__©Œ
+)
+
+911 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+914 

+	$±h»ad_rwlock©Œ_de¡roy
+ (
+±h»ad_rwlock©Œ_t
+ *
+__©Œ
+)
+
+915 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+918 

+	$±h»ad_rwlock©Œ_g‘psh¬ed
+ (
+__cÚ¡
+ 
+±h»ad_rwlock©Œ_t
+ *
+
+919 
+__»¡riù
+ 
+__©Œ
+,
+
+920 *
+__»¡riù
+ 
+__psh¬ed
+)
+
+921 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+924 

+	$±h»ad_rwlock©Œ_£�sh¬ed
+ (
+±h»ad_rwlock©Œ_t
+ *
+__©Œ
+,
+
+925 
+__psh¬ed
+)
+
+926 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+929 

+	$±h»ad_rwlock©Œ_g‘kšd_Å
+ (
+__cÚ¡
+ 
+±h»ad_rwlock©Œ_t
+ *
+
+930 
+__»¡riù
+ 
+__©Œ
+,
+
+931 *
+__»¡riù
+ 
+__´ef
+)
+
+932 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+935 

+	$±h»ad_rwlock©Œ_£tkšd_Å
+ (
+±h»ad_rwlock©Œ_t
+ *
+__©Œ
+,
+
+936 
+__´ef
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+944 

+	$±h»ad_cÚd_š™
+ (
+±h»ad_cÚd_t
+ *
+__»¡riù
+ 
+__cÚd
+,
+
+945 
+__cÚ¡
+ 
+±h»ad_cÚd©Œ_t
+ *
+__»¡riù
+
+
+946 
+__cÚd_©Œ
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+949 

+	$±h»ad_cÚd_de¡roy
+ (
+±h»ad_cÚd_t
+ *
+__cÚd
+)
+
+950 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+953 

+	$±h»ad_cÚd_sigÇl
+ (
+±h»ad_cÚd_t
+ *
+__cÚd
+)
+
+954 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+957 

+	$±h»ad_cÚd_brßdÿ¡
+ (
+±h»ad_cÚd_t
+ *
+__cÚd
+)
+
+958 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+965 

+	$±h»ad_cÚd_wa™
+ (
+±h»ad_cÚd_t
+ *
+__»¡riù
+ 
+__cÚd
+,
+
+966 
+±h»ad_mu‹x_t
+ *
+__»¡riù
+ 
+__mu‹x
+)
+
+967 
+	`__nÚnuÎ
+ ((1, 2));
+
+976 

+	$±h»ad_cÚd_timedwa™
+ (
+±h»ad_cÚd_t
+ *
+__»¡riù
+ 
+__cÚd
+,
+
+977 
+±h»ad_mu‹x_t
+ *
+__»¡riù
+ 
+__mu‹x
+,
+
+978 
+__cÚ¡
+ 
+time¥ec
+ *
+__»¡riù
+
+
+979 
+__ab¡ime
+è
+	`__nÚnuÎ
+ ((1, 2, 3));
+
+984 

+	$±h»ad_cÚd©Œ_š™
+ (
+±h»ad_cÚd©Œ_t
+ *
+__©Œ
+)
+
+985 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+988 

+	$±h»ad_cÚd©Œ_de¡roy
+ (
+±h»ad_cÚd©Œ_t
+ *
+__©Œ
+)
+
+989 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+992 

+	$±h»ad_cÚd©Œ_g‘psh¬ed
+ (
+__cÚ¡
+ 
+±h»ad_cÚd©Œ_t
+ *
+
+993 
+__»¡riù
+ 
+__©Œ
+,
+
+994 *
+__»¡riù
+ 
+__psh¬ed
+)
+
+995 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+998 

+	$±h»ad_cÚd©Œ_£�sh¬ed
+ (
+±h»ad_cÚd©Œ_t
+ *
+__©Œ
+,
+
+999 
+__psh¬ed
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1001 #ifdeà
+__USE_XOPEN2K
+
+
+1003 

+	$±h»ad_cÚd©Œ_g‘þock
+ (
+__cÚ¡
+ 
+±h»ad_cÚd©Œ_t
+ *
+
+1004 
+__»¡riù
+ 
+__©Œ
+,
+
+1005 
+__þockid_t
+ *
+__»¡riù
+ 
+__þock_id
+)
+
+1006 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+1009 

+	$±h»ad_cÚd©Œ_£tþock
+ (
+±h»ad_cÚd©Œ_t
+ *
+__©Œ
+,
+
+1010 
+__þockid_t
+ 
+__þock_id
+)
+
+1011 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1015 #ifdeà
+__USE_XOPEN2K
+
+
+1020 

+	$±h»ad_¥š_š™
+ (
+±h»ad_¥šlock_t
+ *
+__lock
+, 
+__psh¬ed
+)
+
+1021 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1024 

+	$±h»ad_¥š_de¡roy
+ (
+±h»ad_¥šlock_t
+ *
+__lock
+)
+
+1025 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1028 

+	$±h»ad_¥š_lock
+ (
+±h»ad_¥šlock_t
+ *
+__lock
+)
+
+1029 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1032 

+	$±h»ad_¥š_Œylock
+ (
+±h»ad_¥šlock_t
+ *
+__lock
+)
+
+1033 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1036 

+	$±h»ad_¥š_uÆock
+ (
+±h»ad_¥šlock_t
+ *
+__lock
+)
+
+1037 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1044 

+	$±h»ad_b¬r›r_š™
+ (
+±h»ad_b¬r›r_t
+ *
+__»¡riù
+ 
+__b¬r›r
+,
+
+1045 
+__cÚ¡
+ 
+±h»ad_b¬r›¿‰r_t
+ *
+__»¡riù
+
+
+1046 
+__©Œ
+, 
+__couÁ
+)
+
+1047 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1050 

+	$±h»ad_b¬r›r_de¡roy
+ (
+±h»ad_b¬r›r_t
+ *
+__b¬r›r
+)
+
+1051 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1054 

+	$±h»ad_b¬r›r_wa™
+ (
+±h»ad_b¬r›r_t
+ *
+__b¬r›r
+)
+
+1055 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1059 

+	$±h»ad_b¬r›¿‰r_š™
+ (
+±h»ad_b¬r›¿‰r_t
+ *
+__©Œ
+)
+
+1060 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1063 

+	$±h»ad_b¬r›¿‰r_de¡roy
+ (
+±h»ad_b¬r›¿‰r_t
+ *
+__©Œ
+)
+
+1064 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1067 

+	$±h»ad_b¬r›¿‰r_g‘psh¬ed
+ (
+__cÚ¡
+ 
+±h»ad_b¬r›¿‰r_t
+ *
+
+1068 
+__»¡riù
+ 
+__©Œ
+,
+
+1069 *
+__»¡riù
+ 
+__psh¬ed
+)
+
+1070 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2));
+
+1073 

+	$±h»ad_b¬r›¿‰r_£�sh¬ed
+ (
+±h»ad_b¬r›¿‰r_t
+ *
+__©Œ
+,
+
+1074 
+__psh¬ed
+)
+
+1075 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1087 

+	`±h»ad_key_ü—‹
+ (
+±h»ad_key_t
+ *
+__key
+,
+
+1088 (*
+__de¡r_funùiÚ
+) (*))
+
+1089 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+1092 

+	$±h»ad_key_d–‘e
+ (
+±h»ad_key_t
+ 
+__key
+è
+__THROW
+;
+
+1095 
*
+	$±h»ad_g‘¥ecific
+ (
+±h»ad_key_t
+ 
+__key
+è
+__THROW
+;
+
+1098 

+	$±h»ad_£t¥ecific
+ (
+±h»ad_key_t
+ 
+__key
+,
+
+1099 
+__cÚ¡
+ *
+__poš‹r
+è
+__THROW
+ ;
+
+1102 #ifdeà
+__USE_XOPEN2K
+
+
+1104 

+	$±h»ad_g‘ýuþockid
+ (
+±h»ad_t
+ 
+__th»ad_id
+,
+
+1105 
+__þockid_t
+ *
+__þock_id
+)
+
+1106 
+__THROW
+ 
+	`__nÚnuÎ
+ ((2));
+
+1121 

+	`±h»ad_©fÜk
+ ((*
+__´•¬e
+) (),
+
+1122 (*
+__·»Á
+) (),
+
+1123 (*
+__chžd
+è()è
+__THROW
+;
+
+1126 #ifdeà
+__USE_EXTERN_INLINES
+
+
+1128 
+__ex‹º_šlše
+ 
+
+1129 
+	`__NTH
+ (
+	$±h»ad_equ®
+ (
+±h»ad_t
+ 
+__th»ad1
+,…th»ad_ˆ
+__th»ad2
+))
+
+1131  
+__th»ad1
+ =ð
+__th»ad2
+;
+
+1132 
+	}
+}
+
+1135 
+	g__END_DECLS
+
+
+	@/usr/include/wctype.h
+
+24 #iâdeà
+_WCTYPE_H
+
+
+26 
+	~<ã©u»s.h
+>
+
+27 
+	~<b™s/ty³s.h
+>
+
+29 #iâdeà
+__Ãed_iswxxx
+
+
+30 

+	#_WCTYPE_H
+ 1
+
+	)
+
+33 

+	#__Ãed_wšt_t
+
+
+	)
+
+34 
+	~<¡ddef.h
+>
+
+38 #iâdeà
+WEOF
+
+
+39 

+	#WEOF
+ (0xffffffffu)
+
+	)
+
+42 #undeà
+__Ãed_iswxxx
+
+
+47 #iâdeà
+__iswxxx_defšed
+
+
+48 

+	#__iswxxx_defšed
+ 1
+
+	)
+
+50 
+__BEGIN_NAMESPACE_C99
+
+
+53 
+	twùy³_t
+;
+
+54 
+	g__END_NAMESPACE_C99
+
+
+56 #iâdeà
+_ISwb™
+
+
+61 
+	~<’dŸn.h
+>
+
+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__ISw®pha
+ = 2,
+
+77 
+	m__ISwdig™
+ = 3,
+
+78 
+	m__ISwxdig™
+ = 4,
+
+79 
+	m__ISw¥aû
+ = 5,
+
+80 
+	m__ISw´št
+ = 6,
+
+81 
+	m__ISwg¿ph
+ = 7,
+
+82 
+	m__ISwbÏnk
+ = 8,
+
+83 
+	m__ISwúŒl
+ = 9,
+
+84 
+	m__ISwpunù
+ = 10,
+
+85 
+	m__ISw®num
+ = 11,
+
+87 
+	m_ISwuµ”
+ = 
+_ISwb™
+ (
+__ISwuµ”
+),
+
+88 
+	m_ISwlow”
+ = 
+_ISwb™
+ (
+__ISwlow”
+),
+
+89 
+	m_ISw®pha
+ = 
+_ISwb™
+ (
+__ISw®pha
+),
+
+90 
+	m_ISwdig™
+ = 
+_ISwb™
+ (
+__ISwdig™
+),
+
+91 
+	m_ISwxdig™
+ = 
+_ISwb™
+ (
+__ISwxdig™
+),
+
+92 
+	m_ISw¥aû
+ = 
+_ISwb™
+ (
+__ISw¥aû
+),
+
+93 
+	m_ISw´št
+ = 
+_ISwb™
+ (
+__ISw´št
+),
+
+94 
+	m_ISwg¿ph
+ = 
+_ISwb™
+ (
+__ISwg¿ph
+),
+
+95 
+	m_ISwbÏnk
+ = 
+_ISwb™
+ (
+__ISwbÏnk
+),
+
+96 
+	m_ISwúŒl
+ = 
+_ISwb™
+ (
+__ISwúŒl
+),
+
+97 
+	m_ISwpunù
+ = 
+_ISwb™
+ (
+__ISwpunù
+),
+
+98 
+	m_ISw®num
+ = 
+_ISwb™
+ (
+__ISw®num
+)
+
+103 
+__BEGIN_DECLS
+
+
+105 
+__BEGIN_NAMESPACE_C99
+
+
+112 

+	$isw®num
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+118 

+	$isw®pha
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+121 

+	$iswúŒl
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+125 

+	$iswdig™
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+129 

+	$iswg¿ph
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+134 

+	$iswlow”
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+137 

+	$isw´št
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+142 

+	$iswpunù
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+147 

+	$isw¥aû
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+152 

+	$iswuµ”
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+157 

+	$iswxdig™
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+162 #ifdeà
+__USE_ISOC99
+
+
+163 

+	$iswbÏnk
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+172 

+wùy³_t
+ 
+	$wùy³
+ (
+__cÚ¡
+ *
+__´Ý”ty
+è
+__THROW
+;
+
+176 

+	$iswùy³
+ (
+wšt_t
+ 
+__wc
+, 
+wùy³_t
+ 
+__desc
+è
+__THROW
+;
+
+177 
+__END_NAMESPACE_C99
+
+
+184 
+__BEGIN_NAMESPACE_C99
+
+
+187 
+__cÚ¡
+ 
+	t__št32_t
+ *
+	twù¿ns_t
+;
+
+188 
+__END_NAMESPACE_C99
+
+
+189 #ifdeà
+__USE_GNU
+
+
+190 
+	$__USING_NAMESPACE_C99
+(
+wù¿ns_t
+)
+
+193 
+__BEGIN_NAMESPACE_C99
+
+
+195 

+wšt_t
+ 
+	$towlow”
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+198 

+wšt_t
+ 
+	$towuµ”
+ (
+wšt_t
+ 
+__wc
+è
+__THROW
+;
+
+199 
+__END_NAMESPACE_C99
+
+
+201 
+__END_DECLS
+
+
+208 #ifdeà
+_WCTYPE_H
+
+
+214 
+__BEGIN_DECLS
+
+
+216 
+__BEGIN_NAMESPACE_C99
+
+
+219 

+wù¿ns_t
+ 
+	$wù¿ns
+ (
+__cÚ¡
+ *
+__´Ý”ty
+è
+__THROW
+;
+
+222 

+wšt_t
+ 
+	$towù¿ns
+ (
+wšt_t
+ 
+__wc
+, 
+wù¿ns_t
+ 
+__desc
+è
+__THROW
+;
+
+223 
+__END_NAMESPACE_C99
+
+
+225 #ifdeà
+__USE_XOPEN2K8
+
+
+227 
+	~<xloÿË.h
+>
+
+231 

+	$isw®num_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+237 

+	$isw®pha_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+240 

+	$iswúŒl_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+244 

+	$iswdig™_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+248 

+	$iswg¿ph_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+253 

+	$iswlow”_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+256 

+	$isw´št_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+261 

+	$iswpunù_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+266 

+	$isw¥aû_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+271 

+	$iswuµ”_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+276 

+	$iswxdig™_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+281 

+	$iswbÏnk_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+285 

+wùy³_t
+ 
+	$wùy³_l
+ (
+__cÚ¡
+ *
+__´Ý”ty
+, 
+__loÿË_t
+ 
+__loÿË
+)
+
+286 
+__THROW
+;
+
+290 

+	$iswùy³_l
+ (
+wšt_t
+ 
+__wc
+, 
+wùy³_t
+ 
+__desc
+, 
+__loÿË_t
+ 
+__loÿË
+)
+
+291 
+__THROW
+;
+
+299 

+wšt_t
+ 
+	$towlow”_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+302 

+wšt_t
+ 
+	$towuµ”_l
+ (
+wšt_t
+ 
+__wc
+, 
+__loÿË_t
+ 
+__loÿË
+è
+__THROW
+;
+
+306 

+wù¿ns_t
+ 
+	$wù¿ns_l
+ (
+__cÚ¡
+ *
+__´Ý”ty
+, 
+__loÿË_t
+ 
+__loÿË
+)
+
+307 
+__THROW
+;
+
+310 

+wšt_t
+ 
+	$towù¿ns_l
+ (
+wšt_t
+ 
+__wc
+, 
+wù¿ns_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 
+	~<lšux/”ºo.h
+>
+
+28 

+	#ENOTSUP
+ 
+EOPNOTSUPP
+
+
+	)
+
+31 #iâdeà
+ECANCELED
+
+
+32 

+	#ECANCELED
+ 125
+
+	)
+
+36 #iâdeà
+EOWNERDEAD
+
+
+37 

+	#EOWNERDEAD
+ 130
+
+	)
+
+38 

+	#ENOTRECOVERABLE
+ 131
+
+	)
+
+41 #iâdeà
+__ASSEMBLER__
+
+
+43 
*
+	$__”ºo_loÿtiÚ
+ (è
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡__
+));
+
+45 #ià!
+defšed
+ 
+_LIBC
+ || defšed 
+_LIBC_REENTRANT
+
+
+47 

+	#Ӽo
+ (*
+	`__”ºo_loÿtiÚ
+ ())
+
+	)
+
+52 #ià!
+defšed
+ 
+_ERRNO_H
+ && defšed 
+__Ãed_Em©h
+
+
+56 

+	#EDOM
+ 33
+
+	)
+
+57 

+	#EILSEQ
+ 84
+
+	)
+
+58 

+	#ERANGE
+ 34
+
+	)
+
+	@/usr/include/bits/pthreadtypes.h
+
+20 #iâdeà
+_BITS_PTHREADTYPES_H
+
+
+21 

+	#_BITS_PTHREADTYPES_H
+ 1
+
+	)
+
+23 
+	~<b™s/wÜdsize.h
+>
+
+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 
+	t±h»ad_t
+;
+
+55 
+	m__size
+[
+__SIZEOF_PTHREAD_ATTR_T
+];
+
+56 
+	m__®ign
+;
+
+57 } 
+	t±h»ad_©Œ_t
+;
+
+60 #ià
+__WORDSIZE
+ == 64
+
+61 
+	s__±h»ad_š‹º®_li¡
+
+
+63 
+__±h»ad_š‹º®_li¡
+ *
+	m__´ev
+;
+
+64 
+__±h»ad_š‹º®_li¡
+ *
+	m__Ãxt
+;
+
+65 } 
+	t__±h»ad_li¡_t
+;
+
+67 
+	s__±h»ad_š‹º®_¦i¡
+
+
+69 
+__±h»ad_š‹º®_¦i¡
+ *
+	m__Ãxt
+;
+
+70 } 
+	t__±h»ad_¦i¡_t
+;
+
+78 
+	s__±h»ad_mu‹x_s
+
+
+80 
+	m__lock
+;
+
+81 
+	m__couÁ
+;
+
+82 
+	m__owÃr
+;
+
+83 #ià
+__WORDSIZE
+ == 64
+
+84 
+	m__nu£rs
+;
+
+88 
+	m__kšd
+;
+
+89 #ià
+__WORDSIZE
+ == 64
+
+90 
+	m__¥šs
+;
+
+91 
+__±h»ad_li¡_t
+ 
+	m__li¡
+;
+
+92 

+	#__PTHREAD_MUTEX_HAVE_PREV
+ 1
+
+	)
+
+94 
+	m__nu£rs
+;
+
+95 
+__ex‹nsiÚ__
+ union
+
+97 
+	m__¥šs
+;
+
+98 
+__±h»ad_¦i¡_t
+ 
+	m__li¡
+;
+
+101 } 
+	m__d©a
+;
+
+102 
+	m__size
+[
+__SIZEOF_PTHREAD_MUTEX_T
+];
+
+103 
+	m__®ign
+;
+
+104 } 
+	t±h»ad_mu‹x_t
+;
+
+108 
+	m__size
+[
+__SIZEOF_PTHREAD_MUTEXATTR_T
+];
+
+109 
+	m__®ign
+;
+
+110 } 
+	t±h»ad_mu‹x©Œ_t
+;
+
+119 
+	m__lock
+;
+
+120 
+	m__fu‹x
+;
+
+121 
+__ex‹nsiÚ__
+ 
+	m__tÙ®_£q
+;
+
+122 
+__ex‹nsiÚ__
+ 
+	m__wakeup_£q
+;
+
+123 
+__ex‹nsiÚ__
+ 
+	m__wok’_£q
+;
+
+124 *
+	m__mu‹x
+;
+
+125 
+	m__nwa™”s
+;
+
+126 
+	m__brßdÿ¡_£q
+;
+
+127 } 
+	m__d©a
+;
+
+128 
+	m__size
+[
+__SIZEOF_PTHREAD_COND_T
+];
+
+129 
+__ex‹nsiÚ__
+ 
+	m__®ign
+;
+
+130 } 
+	t±h»ad_cÚd_t
+;
+
+134 
+	m__size
+[
+__SIZEOF_PTHREAD_CONDATTR_T
+];
+
+135 
+	m__®ign
+;
+
+136 } 
+	t±h»ad_cÚd©Œ_t
+;
+
+140 
+	t±h»ad_key_t
+;
+
+144 
+	t±h»ad_Úû_t
+;
+
+147 #ià
+defšed
+ 
+__USE_UNIX98
+ || defšed 
+__USE_XOPEN2K
+
+
+152 #ià
+__WORDSIZE
+ == 64
+
+155 
+	m__lock
+;
+
+156 
+	m__Ä_»ad”s
+;
+
+157 
+	m__»ad”s_wakeup
+;
+
+158 
+	m__wr™”_wakeup
+;
+
+159 
+	m__Ä_»ad”s_queued
+;
+
+160 
+	m__Ä_wr™”s_queued
+;
+
+161 
+	m__wr™”
+;
+
+162 
+	m__sh¬ed
+;
+
+163 
+	m__·d1
+;
+
+164 
+	m__·d2
+;
+
+167 
+	m__æags
+;
+
+168 } 
+	m__d©a
+;
+
+172 
+	m__lock
+;
+
+173 
+	m__Ä_»ad”s
+;
+
+174 
+	m__»ad”s_wakeup
+;
+
+175 
+	m__wr™”_wakeup
+;
+
+176 
+	m__Ä_»ad”s_queued
+;
+
+177 
+	m__Ä_wr™”s_queued
+;
+
+180 
+	m__æags
+;
+
+181 
+	m__sh¬ed
+;
+
+182 
+	m__·d1
+;
+
+183 
+	m__·d2
+;
+
+184 
+	m__wr™”
+;
+
+185 } 
+	m__d©a
+;
+
+187 
+	m__size
+[
+__SIZEOF_PTHREAD_RWLOCK_T
+];
+
+188 
+	m__®ign
+;
+
+189 } 
+	t±h»ad_rwlock_t
+;
+
+193 
+	m__size
+[
+__SIZEOF_PTHREAD_RWLOCKATTR_T
+];
+
+194 
+	m__®ign
+;
+
+195 } 
+	t±h»ad_rwlock©Œ_t
+;
+
+199 #ifdeà
+__USE_XOPEN2K
+
+
+201 vÞ©ž�
+	t±h»ad_¥šlock_t
+;
+
+208 
+	m__size
+[
+__SIZEOF_PTHREAD_BARRIER_T
+];
+
+209 
+	m__®ign
+;
+
+210 } 
+	t±h»ad_b¬r›r_t
+;
+
+214 
+	m__size
+[
+__SIZEOF_PTHREAD_BARRIERATTR_T
+];
+
+215 
+	m__®ign
+;
+
+216 } 
+	t±h»ad_b¬r›¿‰r_t
+;
+
+220 #ià
+__WORDSIZE
+ == 32
+
+222 

+	#__þ—nup_fù_©Œibu‹
+ 
+	`__©Œibu‹__
+ ((
+	`__»g·rm__
+ (1)))
+
+	)
+
+	@/usr/include/bits/setjmp.h
+
+20 #iâdeà
+_BITS_SETJMP_H
+
+
+21 

+	#_BITS_SETJMP_H
+ 1
+
+	)
+
+23 #ià!
+defšed
+ 
+_SETJMP_H
+ && !defšed 
+_PTHREAD_H
+
+
+27 
+	~<b™s/wÜdsize.h
+>
+
+29 #iâdeà
+_ASM
+
+
+31 #ià
+__WORDSIZE
+ == 64
+
+32 
+	t__jmp_buf
+[8];
+
+34 
+	t__jmp_buf
+[6];
+
+	@/usr/include/sched.h
+
+20 #iâdef 
+_SCHED_H
+
+
+21 

+	#_SCHED_H
+ 1
+
+	)
+
+23 
+	~<ã©u»s.h
+>
+
+26 
+	~<b™s/ty³s.h
+>
+
+28 

+	#__Ãed_size_t
+
+
+	)
+
+29 
+	~<¡ddef.h
+>
+
+31 

+	#__Ãed_time¥ec
+
+
+	)
+
+32 
+	~<time.h
+>
+
+35 
+	~<b™s/sched.h
+>
+
+37 

+	#sched_´iÜ™y
+ 
+__sched_´iÜ™y
+
+
+	)
+
+40 
+__BEGIN_DECLS
+
+
+43 

+	$sched_£�¬am
+ (
+__pid_t
+ 
+__pid
+, 
+__cÚ¡
+ 
+sched_·¿m
+ *
+__·¿m
+)
+
+44 
+__THROW
+;
+
+47 

+	$sched_g‘·¿m
+ (
+__pid_t
+ 
+__pid
+, 
+sched_·¿m
+ *
+__·¿m
+è
+__THROW
+;
+
+50 

+	$sched_£tscheduËr
+ (
+__pid_t
+ 
+__pid
+, 
+__pÞicy
+,
+
+51 
+__cÚ¡
+ 
+sched_·¿m
+ *
+__·¿m
+è
+__THROW
+;
+
+54 

+	$sched_g‘scheduËr
+ (
+__pid_t
+ 
+__pid
+è
+__THROW
+;
+
+57 

+	$sched_y›ld
+ (è
+__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
+, 
+time¥ec
+ *
+__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, s‘size, cpu£�)
+
+	)
+
+80 

+	#CPU_CLR_S
+(
+ýu
+, 
+£tsize
+, 
+ýu£�
+è
+	`__CPU_CLR_S
+ (ýu, s‘size, 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
+(
+ýu£�1
+, 
+ýu£�2
+) \
+
+87 
+	`__CPU_EQUAL_S
+ ( (
+ýu_£t_t
+), 
+ýu£�1
+, 
+ýu£�2
+)
+
+	)
+
+88 

+	#CPU_EQUAL_S
+(
+£tsize
+, 
+ýu£�1
+, 
+ýu£�2
+) \
+
+89 
+	`__CPU_EQUAL_S
+ (
+£tsize
+, 
+ýu£�1
+, 
+ýu£�2
+)
+
+	)
+
+91 

+	#CPU_AND
+(
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+) \
+
+92 
+	`__CPU_OP_S
+ ( (
+ýu_£t_t
+), 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, &)
+
+	)
+
+93 

+	#CPU_OR
+(
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+) \
+
+94 
+	`__CPU_OP_S
+ ( (
+ýu_£t_t
+), 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, |)
+
+	)
+
+95 

+	#CPU_XOR
+(
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+) \
+
+96 
+	`__CPU_OP_S
+ ( (
+ýu_£t_t
+), 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, ^)
+
+	)
+
+97 

+	#CPU_AND_S
+(
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+) \
+
+98 
+	`__CPU_OP_S
+ (
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, &)
+
+	)
+
+99 

+	#CPU_OR_S
+(
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+) \
+
+100 
+	`__CPU_OP_S
+ (
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, |)
+
+	)
+
+101 

+	#CPU_XOR_S
+(
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+) \
+
+102 
+	`__CPU_OP_S
+ (
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, ^)
+
+	)
+
+104 

+	#CPU_ALLOC_SIZE
+(
+couÁ
+è
+	`__CPU_ALLOC_SIZE
+ (couÁ)
+
+	)
+
+105 

+	#CPU_ALLOC
+(
+couÁ
+è
+	`__CPU_ALLOC
+ (couÁ)
+
+	)
+
+106 

+	#CPU_FREE
+(
+ýu£t
+è
+	`__CPU_FREE
+ (ýu£t)
+
+	)
+
+110 

+	$sched_£�ffš™y
+ (
+__pid_t
+ 
+__pid
+, 
+size_t
+ 
+__ýu£tsize
+,
+
+111 
+__cÚ¡
+ 
+ýu_£t_t
+ *
+__ýu£t
+è
+__THROW
+;
+
+114 

+	$sched_g‘affš™y
+ (
+__pid_t
+ 
+__pid
+, 
+size_t
+ 
+__ýu£tsize
+,
+
+115 
+ýu_£t_t
+ *
+__ýu£t
+è
+__THROW
+;
+
+118 
+__END_DECLS
+
+
+	@/usr/include/signal.h
+
+23 #iâdef 
+_SIGNAL_H
+
+
+25 #ià!
+defšed
+ 
+__Ãed_sig_©omic_t
+ && !defšed 
+__Ãed_sig£t_t
+
+
+26 

+	#_SIGNAL_H
+
+
+	)
+
+29 
+	~<ã©u»s.h
+>
+
+31 
+	g__BEGIN_DECLS
+
+
+33 
+	~<b™s/sig£t.h
+>
+
+37 #ià
+defšed
+ 
+__Ãed_sig_©omic_t
+ || defšed 
+_SIGNAL_H
+
+
+38 #iâdeà
+__sig_©omic_t_defšed
+
+
+39 

+	#__sig_©omic_t_defšed
+
+
+	)
+
+40 
+__BEGIN_NAMESPACE_STD
+
+
+41 
+__sig_©omic_t
+ 
+	tsig_©omic_t
+;
+
+42 
+	g__END_NAMESPACE_STD
+
+
+44 #undeà
+__Ãed_sig_©omic_t
+
+
+47 #ià
+defšed
+ 
+__Ãed_sig£t_t
+ || (defšed 
+_SIGNAL_H
+ && defšed 
+__USE_POSIX
+)
+
+48 #iâdeà
+__sig£t_t_defšed
+
+
+49 

+	#__sig£t_t_defšed
+
+
+	)
+
+50 
+__sig£t_t
+ 
+	tsig£t_t
+;
+
+52 #undeà
+__Ãed_sig£t_t
+
+
+55 #ifdeà
+_SIGNAL_H
+
+
+57 
+	~<b™s/ty³s.h
+>
+
+58 
+	~<b™s/signum.h
+>
+
+60 #ià
+defšed
+ 
+__USE_XOPEN
+ || defšed 
+__USE_XOPEN2K
+
+
+61 #iâdeà
+__pid_t_defšed
+
+
+62 
+__pid_t
+ 
+	tpid_t
+;
+
+63 

+	#__pid_t_defšed
+
+
+	)
+
+65 #ifdeà
+__USE_XOPEN
+
+
+67 #iâdeà
+__uid_t_defšed
+
+
+68 
+__uid_t
+ 
+	tuid_t
+;
+
+69 

+	#__uid_t_defšed
+
+
+	)
+
+73 #ifdeà
+__USE_POSIX199309
+
+
+75 

+	#__Ãed_time¥ec
+
+
+	)
+
+76 
+	~<time.h
+>
+
+79 
+	~<b™s/sigšfo.h
+>
+
+84 (*
+	t__sighªdËr_t
+) ();
+
+89 

+__sighªdËr_t
+ 
+	$__sysv_sigÇl
+ (
+__sig
+, 
+__sighªdËr_t
+ 
+__hªdËr
+)
+
+90 
+__THROW
+;
+
+91 #ifdeà
+__USE_GNU
+
+
+92 

+__sighªdËr_t
+ 
+	$sysv_sigÇl
+ (
+__sig
+, 
+__sighªdËr_t
+ 
+__hªdËr
+)
+
+93 
+__THROW
+;
+
+99 
+__BEGIN_NAMESPACE_STD
+
+
+100 #ifdeà
+__USE_BSD
+
+
+101 

+__sighªdËr_t
+ 
+	$sigÇl
+ (
+__sig
+, 
+__sighªdËr_t
+ 
+__hªdËr
+)
+
+102 
+__THROW
+;
+
+105 #ifdeà
+__REDIRECT_NTH
+
+
+106 

+__sighªdËr_t
+ 
+	`__REDIRECT_NTH
+ (
+sigÇl
+,
+
+107 (
+__sig
+, 
+__sighªdËr_t
+ 
+__hªdËr
+),
+
+108 
+__sysv_sigÇl
+);
+
+110 

+	#sigÇl
+ 
+__sysv_sigÇl
+
+
+	)
+
+113 
+__END_NAMESPACE_STD
+
+
+115 #ifdeà
+__USE_XOPEN
+
+
+118 

+__sighªdËr_t
+ 
+	$bsd_sigÇl
+ (
+__sig
+, 
+__sighªdËr_t
+ 
+__hªdËr
+)
+
+119 
+__THROW
+;
+
+125 #ifdeà
+__USE_POSIX
+
+
+126 

+	$kžl
+ (
+__pid_t
+ 
+__pid
+, 
+__sig
+è
+__THROW
+;
+
+129 #ià
+defšed
+ 
+__USE_BSD
+ || defšed 
+__USE_XOPEN_EXTENDED
+
+
+133 

+	$kžÍg
+ (
+__pid_t
+ 
+__pg½
+, 
+__sig
+è
+__THROW
+;
+
+136 
+__BEGIN_NAMESPACE_STD
+
+
+138 

+	$¿i£
+ (
+__sig
+è
+__THROW
+;
+
+139 
+__END_NAMESPACE_STD
+
+
+141 #ifdeà
+__USE_SVID
+
+
+143 

+__sighªdËr_t
+ 
+	$ssigÇl
+ (
+__sig
+, 
+__sighªdËr_t
+ 
+__hªdËr
+)
+
+144 
+__THROW
+;
+
+145 

+	$gsigÇl
+ (
+__sig
+è
+__THROW
+;
+
+148 #ià
+defšed
+ 
+__USE_MISC
+ || defšed 
+__USE_XOPEN2K
+
+
+150 

+	`psigÇl
+ (
+__sig
+, 
+__cÚ¡
+ *
+__s
+);
+
+153 #ifdeà
+__USE_XOPEN2K
+
+
+155 

+	`psigšfo
+ (
+__cÚ¡
+ 
+sigšfo_t
+ *
+__pšfo
+, __cÚ¡ *
+__s
+);
+
+168 

+	`__sig·u£
+ (
+__sig_Ü_mask
+, 
+__is_sig
+);
+
+170 #ifdeà
+__FAVOR_BSD
+
+
+173 

+	$sig·u£
+ (
+__mask
+è
+__THROW
+ 
+__©Œibu‹_d•»ÿ‹d__
+;
+
+175 #ifdeà
+__USE_XOPEN
+
+
+176 #ifdeà
+__GNUC__
+
+
+177 

+	$sig·u£
+ (
+__sig
+è
+	`__asm__
+ ("__xpg_sigpause");
+
+180 

+	#sig·u£
+(
+sig
+è
+	`__sig·u£
+ ((sig), 1)
+
+	)
+
+186 #ifdeà
+__USE_BSD
+
+
+193 

+	#sigmask
+(
+sig
+è
+	`__sigmask
+(sig)
+
+	)
+
+196 

+	$sigblock
+ (
+__mask
+è
+__THROW
+ 
+__©Œibu‹_d•»ÿ‹d__
+;
+
+199 

+	$sig£tmask
+ (
+__mask
+è
+__THROW
+ 
+__©Œibu‹_d•»ÿ‹d__
+;
+
+202 

+	$sigg‘mask
+ (è
+__THROW
+ 
+__©Œibu‹_d•»ÿ‹d__
+;
+
+206 #ifdeà
+__USE_MISC
+
+
+207 

+	#NSIG
+ 
+_NSIG
+
+
+	)
+
+210 #ifdeà
+__USE_GNU
+
+
+211 
+__sighªdËr_t
+ 
+	tsighªdËr_t
+;
+
+215 #ifdeà
+__USE_BSD
+
+
+216 
+__sighªdËr_t
+ 
+	tsig_t
+;
+
+219 #ifdeà
+__USE_POSIX
+
+
+222 

+	$sigem±y£t
+ (
+sig£t_t
+ *
+__£t
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+225 

+	$sigfžl£t
+ (
+sig£t_t
+ *
+__£t
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+228 

+	$sigadd£t
+ (
+sig£t_t
+ *
+__£t
+, 
+__signo
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+231 

+	$sigd–£t
+ (
+sig£t_t
+ *
+__£t
+, 
+__signo
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+234 

+	$sigismemb”
+ (
+__cÚ¡
+ 
+sig£t_t
+ *
+__£t
+, 
+__signo
+)
+
+235 
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+237 #ifdeà
+__USE_GNU
+
+
+239 

+	$sigi£m±y£t
+ (
+__cÚ¡
+ 
+sig£t_t
+ *
+__£t
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+242 

+	$sigªd£t
+ (
+sig£t_t
+ *
+__£t
+, 
+__cÚ¡
+ sig£t_ˆ*
+__Ëá
+,
+
+243 
+__cÚ¡
+ 
+sig£t_t
+ *
+__right
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2, 3));
+
+246 

+	$sigܣt
+ (
+sig£t_t
+ *
+__£t
+, 
+__cÚ¡
+ sig£t_ˆ*
+__Ëá
+,
+
+247 
+__cÚ¡
+ 
+sig£t_t
+ *
+__right
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1, 2, 3));
+
+252 
+	~<b™s/sigaùiÚ.h
+>
+
+255 

+	$sig´ocmask
+ (
+__how
+, 
+__cÚ¡
+ 
+sig£t_t
+ *
+__»¡riù
+ 
+__£t
+,
+
+256 
+sig£t_t
+ *
+__»¡riù
+ 
+__o£t
+è
+__THROW
+;
+
+263 

+	$sigsu¥’d
+ (
+__cÚ¡
+ 
+sig£t_t
+ *
+__£t
+è
+	`__nÚnuÎ
+ ((1));
+
+266 

+	$sigaùiÚ
+ (
+__sig
+, 
+__cÚ¡
+ 
+sigaùiÚ
+ *
+__»¡riù
+ 
+__aù
+,
+
+267 
+sigaùiÚ
+ *
+__»¡riù
+ 
+__ßù
+è
+__THROW
+;
+
+270 

+	$sig³ndšg
+ (
+sig£t_t
+ *
+__£t
+è
+__THROW
+ 
+	`__nÚnuÎ
+ ((1));
+
+277 

+	$sigwa™
+ (
+__cÚ¡
+ 
+sig£t_t
+ *
+__»¡riù
+ 
+__£t
+, *__»¡riù 
+__sig
+)
+
+278 
+	`__nÚnuÎ
+ ((1, 2));
+
+280 #ifdeà
+__USE_POSIX199309
+
+
+285 

+	$sigwa™šfo
+ (
+__cÚ¡
+ 
+sig£t_t
+ *
+__»¡riù
+ 
+__£t
+,
+
+286 
+sigšfo_t
+ *
+__»¡riù
+ 
+__šfo
+è
+	`__nÚnuÎ
+ ((1));
+
+293 

+	$sigtimedwa™
+ (
+__cÚ¡
+ 
+sig£t_t
+ *
+__»¡riù
+ 
+__£t
+,
+
+294 
+sigšfo_t
+ *
+__»¡riù
+ 
+__šfo
+,
+
+295 
+__cÚ¡
+ 
+time¥ec
+ *
+__»¡riù
+ 
+__timeout
+)
+
+296 
+	`__nÚnuÎ
+ ((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 
+__sighªdËr_t
+ 
+sv_hªdËr
+;
+
+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 
+	~<b™s/sigcÚ‹xt.h
+>
+
+342 

+	$sig»tuº
+ (
+sigcÚ‹xt
+ *
+__sý
+è
+__THROW
+;
+
+347 #ià
+defšed
+ 
+__USE_BSD
+ || defšed 
+__USE_XOPEN_EXTENDED
+
+
+348 

+	#__Ãed_size_t
+
+
+	)
+
+349 
+	~<¡ddef.h
+>
+
+354 

+	$sigš‹¼u±
+ (
+__sig
+, 
+__š‹¼u±
+è
+__THROW
+;
+
+356 
+	~<b™s/sig¡ack.h
+>
+
+357 #ifdeà
+__USE_XOPEN
+
+
+359 
+	~<sys/ucÚ‹xt.h
+>
+
+365 

+	$sig¡ack
+ (
+sig¡ack
+ *
+__ss
+, sig¡ack *
+__oss
+)
+
+366 
+__THROW
+ 
+__©Œibu‹_d•»ÿ‹d__
+;
+
+370 

+	$sig®t¡ack
+ (
+__cÚ¡
+ 
+sig®t¡ack
+ *
+__»¡riù
+ 
+__ss
+,
+
+371 
+sig®t¡ack
+ *
+__»¡riù
+ 
+__oss
+è
+__THROW
+;
+
+375 #ifdeà
+__USE_XOPEN_EXTENDED
+
+
+379 

+	$sighÞd
+ (
+__sig
+è
+__THROW
+;
+
+382 

+	$sig»l£
+ (
+__sig
+è
+__THROW
+;
+
+385 

+	$sigignÜe
+ (
+__sig
+è
+__THROW
+;
+
+388 

+__sighªdËr_t
+ 
+	$sig£t
+ (
+__sig
+, 
+__sighªdËr_t
+ 
+__di¥
+è
+__THROW
+;
+
+391 #ià
+defšed
+ 
+__USE_POSIX199506
+ || defšed 
+__USE_UNIX98
+
+
+394 
+	~<b™s/±h»adty³s.h
+>
+
+395 
+	~<b™s/sigth»ad.h
+>
+
+402 

+	$__libc_cu¼’t_sig¹mš
+ (è
+__THROW
+;
+
+404 

+	$__libc_cu¼’t_sig¹max
+ (è
+__THROW
+;
+
+408 
+__END_DECLS
+
+
+	@/usr/include/time.h
+
+23 #iâdef 
+_TIME_H
+
+
+25 #ià(! 
+defšed
+ 
+__Ãed_time_t
+ && !defšed 
+__Ãed_þock_t
+ && \
+
+26 ! 
+defšed
+ 
+	g__Ãed_time¥ec
+)
+
+27 

+	#_TIME_H
+ 1
+
+	)
+
+28 
+	~<ã©u»s.h
+>
+
+30 
+	g__BEGIN_DECLS
+
+
+34 #ifdef 
+_TIME_H
+
+
+36 

+	#__Ãed_size_t
+
+
+	)
+
+37 

+	#__Ãed_NULL
+
+
+	)
+
+38 
+	~<¡ddef.h
+>
+
+42 
+	~<b™s/time.h
+>
+
+45 #ià!
+defšed
+ 
+__STRICT_ANSI__
+ && !defšed 
+__USE_XOPEN2K
+
+
+46 #iâdeà
+CLK_TCK
+
+
+47 

+	#CLK_TCK
+ 
+CLOCKS_PER_SEC
+
+
+	)
+
+53 #ià!
+defšed
+ 
+__þock_t_defšed
+ && (defšed 
+_TIME_H
+ || defšed 
+__Ãed_þock_t
+)
+
+54 

+	#__þock_t_defšed
+ 1
+
+	)
+
+56 
+	~<b™s/ty³s.h
+>
+
+58 
+__BEGIN_NAMESPACE_STD
+
+
+60 
+__þock_t
+ 
+	tþock_t
+;
+
+61 
+	g__END_NAMESPACE_STD
+
+
+62 #ià
+defšed
+ 
+__USE_XOPEN
+ || defšed 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+63 
+	$__USING_NAMESPACE_STD
+(
+þock_t
+)
+
+67 #undeà
+__Ãed_þock_t
+
+
+69 #ià!
+defšed
+ 
+__time_t_defšed
+ && (defšed 
+_TIME_H
+ || defšed 
+__Ãed_time_t
+)
+
+70 

+	#__time_t_defšed
+ 1
+
+	)
+
+72 
+	~<b™s/ty³s.h
+>
+
+74 
+__BEGIN_NAMESPACE_STD
+
+
+76 
+__time_t
+ 
+	ttime_t
+;
+
+77 
+__END_NAMESPACE_STD
+
+
+78 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+ || defšed 
+__USE_SVID
+
+
+79 
+	$__USING_NAMESPACE_STD
+(
+time_t
+)
+
+83 #undeà
+__Ãed_time_t
+
+
+85 #ià!
+defšed
+ 
+__þockid_t_defšed
+ && \
+
+86 ((
+defšed
+ 
+_TIME_H
+ && defšed 
+__USE_POSIX199309
+è|| defšed 
+__Ãed_þockid_t
+)
+
+87 

+	#__þockid_t_defšed
+ 1
+
+	)
+
+89 
+	~<b™s/ty³s.h
+>
+
+92 
+__þockid_t
+ 
+	tþockid_t
+;
+
+95 #undeà
+__þockid_time_t
+
+
+97 #ià!
+defšed
+ 
+__tim”_t_defšed
+ && \
+
+98 ((
+defšed
+ 
+_TIME_H
+ && defšed 
+__USE_POSIX199309
+è|| defšed 
+__Ãed_tim”_t
+)
+
+99 

+	#__tim”_t_defšed
+ 1
+
+	)
+
+101 
+	~<b™s/ty³s.h
+>
+
+104 
+__tim”_t
+ 
+	ttim”_t
+;
+
+107 #undeà
+__Ãed_tim”_t
+
+
+110 #ià!
+defšed
+ 
+__time¥ec_defšed
+ && \
+
+111 ((
+defšed
+ 
+_TIME_H
+ && \
+
+112 (
+defšed
+ 
+__USE_POSIX199309
+ || defšed 
+__USE_MISC
+)) || \
+
+113 
+defšed
+ 
+__Ãed_time¥ec
+)
+
+114 

+	#__time¥ec_defšed
+ 1
+
+	)
+
+116 
+	~<b™s/ty³s.h
+>
+
+120 
+	stime¥ec
+
+
+122 
+__time_t
+ 
+tv_£c
+;
+
+123 
+tv_n£c
+;
+
+127 #undeà
+__Ãed_time¥ec
+
+
+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_y—r
+;
+
+141 
+tm_wday
+;
+
+142 
+tm_yday
+;
+
+143 
+tm_isd¡
+;
+
+145 #ifdef 
+__USE_BSD
+
+
+146 
+tm_gmtoff
+;
+
+147 
+__cÚ¡
+ *
+tm_zÚe
+;
+
+149 
+__tm_gmtoff
+;
+
+150 
+__cÚ¡
+ *
+__tm_zÚe
+;
+
+153 
+__END_NAMESPACE_STD
+
+
+154 #ià
+defšed
+ 
+__USE_XOPEN
+ || defšed 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+155 
+	$__USING_NAMESPACE_STD
+(
+tm
+)
+
+159 #ifdeà
+__USE_POSIX199309
+
+
+161 
+	s™im”¥ec
+
+
+163 
+time¥ec
+ 
+™_š‹rv®
+;
+
+164 
+time¥ec
+ 
+™_v®ue
+;
+
+168 
+sigev’t
+;
+
+172 #ifdeà
+__USE_XOPEN2K
+
+
+173 #iâdeà
+__pid_t_defšed
+
+
+174 
+__pid_t
+ 
+	tpid_t
+;
+
+175 

+	#__pid_t_defšed
+
+
+	)
+
+180 
+__BEGIN_NAMESPACE_STD
+
+
+183 

+þock_t
+ 
+	$þock
+ (è
+__THROW
+;
+
+186 

+time_t
+ 
+	$time
+ (
+time_t
+ *
+__tim”
+è
+__THROW
+;
+
+189 

+	$difáime
+ (
+time_t
+ 
+__time1
+,�ime_ˆ
+__time0
+)
+
+190 
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡__
+));
+
+193 

+time_t
+ 
+	$mktime
+ (
+tm
+ *
+__�
+è
+__THROW
+;
+
+199 

+size_t
+ 
+	$¡ráime
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__maxsize
+,
+
+200 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+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 
+	~<xloÿË.h
+>
+
+217 

+size_t
+ 
+	$¡ráime_l
+ (*
+__»¡riù
+ 
+__s
+, 
+size_t
+ 
+__maxsize
+,
+
+218 
+__cÚ¡
+ *
+__»¡riù
+ 
+__fÜm©
+,
+
+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
+ *
+	$loÿÉime
+ (
+__cÚ¡
+ 
+time_t
+ *
+__tim”
+è
+__THROW
+;
+
+238 
+__END_NAMESPACE_STD
+
+
+240 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+243 

+tm
+ *
+	$gmtime_r
+ (
+__cÚ¡
+ 
+time_t
+ *
+__»¡riù
+ 
+__tim”
+,
+
+244 
+tm
+ *
+__»¡riù
+ 
+__�
+è
+__THROW
+;
+
+248 

+tm
+ *
+	$loÿÉime_r
+ (
+__cÚ¡
+ 
+time_t
+ *
+__»¡riù
+ 
+__tim”
+,
+
+249 
+tm
+ *
+__»¡riù
+ 
+__�
+è
+__THROW
+;
+
+252 
+__BEGIN_NAMESPACE_STD
+
+
+255 
*
+	$asùime
+ (
+__cÚ¡
+ 
+tm
+ *
+__�
+è
+__THROW
+;
+
+258 
*
+	$ùime
+ (
+__cÚ¡
+ 
+time_t
+ *
+__tim”
+è
+__THROW
+;
+
+259 
+__END_NAMESPACE_STD
+
+
+261 #ià
+defšed
+ 
+__USE_POSIX
+ || defšed 
+__USE_MISC
+
+
+266 
*
+	$asùime_r
+ (
+__cÚ¡
+ 
+tm
+ *
+__»¡riù
+ 
+__�
+,
+
+267 *
+__»¡riù
+ 
+__buf
+è
+__THROW
+;
+
+270 
*
+	$ùime_r
+ (
+__cÚ¡
+ 
+time_t
+ *
+__»¡riù
+ 
+__tim”
+,
+
+271 *
+__»¡riù
+ 
+__buf
+è
+__THROW
+;
+
+276 
*
+__tzÇme
+[2];
+
+277 

+__daylight
+;
+
+278 

+__timezÚe
+;
+
+281 #ifdef 
+__USE_POSIX
+
+
+283 
*
+tzÇme
+[2];
+
+287 

+	$tz£t
+ (è
+__THROW
+;
+
+290 #ià
+defšed
+ 
+__USE_SVID
+ || defšed 
+__USE_XOPEN
+
+
+291 

+daylight
+;
+
+292 

+timezÚe
+;
+
+295 #ifdeà
+__USE_SVID
+
+
+298 

+	$¡ime
+ (
+__cÚ¡
+ 
+time_t
+ *
+__wh’
+è
+__THROW
+;
+
+304 

+	#__i¦—p
+(
+y—r
+) \
+
+305 ((
+y—r
+è% 4 =ð0 && ((y—rè% 100 !ð0 || (y—rè% 400 =ð0))
+
+	)
+
+308 #ifdeà
+__USE_MISC
+
+
+313 

+time_t
+ 
+	$timegm
+ (
+tm
+ *
+__�
+è
+__THROW
+;
+
+316 

+time_t
+ 
+	$tim–oÿl
+ (
+tm
+ *
+__�
+è
+__THROW
+;
+
+319 

+	$dysize
+ (
+__y—r
+è
+__THROW
+ 
+	`__©Œibu‹__
+ ((
+__cÚ¡__
+));
+
+323 #ifdeà
+__USE_POSIX199309
+
+
+328 

+	`Çno¦“p
+ (
+__cÚ¡
+ 
+time¥ec
+ *
+__»que¡ed_time
+,
+
+329 
+time¥ec
+ *
+__»maššg
+);
+
+333 

+	$þock_g‘»s
+ (
+þockid_t
+ 
+__þock_id
+, 
+time¥ec
+ *
+__»s
+è
+__THROW
+;
+
+336 

+	$þock_g‘time
+ (
+þockid_t
+ 
+__þock_id
+, 
+time¥ec
+ *
+__�
+è
+__THROW
+;
+
+339 

+	$þock_£‰ime
+ (
+þockid_t
+ 
+__þock_id
+, 
+__cÚ¡
+ 
+time¥ec
+ *
+__�
+)
+
+340 
+__THROW
+;
+
+342 #ifdeà
+__USE_XOPEN2K
+
+
+347 

+	`þock_Çno¦“p
+ (
+þockid_t
+ 
+__þock_id
+, 
+__æags
+,
+
+348 
+__cÚ¡
+ 
+time¥ec
+ *
+__»q
+,
+
+349 
+time¥ec
+ *
+__»m
+);
+
+352 

+	$þock_g‘ýuþockid
+ (
+pid_t
+ 
+__pid
+, 
+þockid_t
+ *
+__þock_id
+è
+__THROW
+;
+
+357 

+	$tim”_ü—‹
+ (
+þockid_t
+ 
+__þock_id
+,
+
+358 
+sigev’t
+ *
+__»¡riù
+ 
+__evp
+,
+
+359 
+tim”_t
+ *
+__»¡riù
+ 
+__tim”id
+è
+__THROW
+;
+
+362 

+	$tim”_d–‘e
+ (
+tim”_t
+ 
+__tim”id
+è
+__THROW
+;
+
+365 

+	$tim”_£‰ime
+ (
+tim”_t
+ 
+__tim”id
+, 
+__æags
+,
+
+366 
+__cÚ¡
+ 
+™im”¥ec
+ *
+__»¡riù
+ 
+__v®ue
+,
+
+367 
+™im”¥ec
+ *
+__»¡riù
+ 
+__ov®ue
+è
+__THROW
+;
+
+370 

+	$tim”_g‘time
+ (
+tim”_t
+ 
+__tim”id
+, 
+™im”¥ec
+ *
+__v®ue
+)
+
+371 
+__THROW
+;
+
+374 

+	$tim”_g‘ov”run
+ (
+tim”_t
+ 
+__tim”id
+è
+__THROW
+;
+
+378 #ifdeà
+__USE_XOPEN_EXTENDED
+
+
+390 

+g‘d©e_”r
+;
+
+399 

+tm
+ *
+	`g‘d©e
+ (
+__cÚ¡
+ *
+__¡ršg
+);
+
+402 #ifdeà
+__USE_GNU
+
+
+413 

+	`g‘d©e_r
+ (
+__cÚ¡
+ *
+__»¡riù
+ 
+__¡ršg
+,
+
+414 
+tm
+ *
+__»¡riù
+ 
+__»sbuå
+);
+
+417 
+__END_DECLS
+
+
+	@/usr/include/bits/sched.h
+
+22 #iâdeà
+__Ãed_sched·¿m
+
+
+24 #iâdeà
+_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
+), *
+__chžd_¡ack
+,
+
+81 
+__æags
+, *
+__¬g
+, ...è
+__THROW
+;
+
+84 

+	$unsh¬e
+ (
+__æags
+è
+__THROW
+;
+
+87 

+	$sched_g‘ýu
+ (è
+__THROW
+;
+
+90 
+__END_DECLS
+
+
+94 #ià!
+defšed
+ 
+__defšed_sched·¿m
+ \
+
+95 && (
+defšed
+ 
+__Ãed_sched·¿m
+ || defšed 
+_SCHED_H
+)
+
+96 

+	#__defšed_sched·¿m
+ 1
+
+	)
+
+98 
+	s__sched_·¿m
+
+
+100 
+__sched_´iÜ™y
+;
+
+102 #undeà
+__Ãed_sched·¿m
+
+
+106 #ià
+defšed
+ 
+_SCHED_H
+ && !defšed 
+__ýu_£t_t_defšed
+
+
+107 

+	#__ýu_£t_t_defšed
+
+
+	)
+
+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
+ 
+__b™s
+[
+__CPU_SETSIZE
+ / 
+__NCPUBITS
+];
+
+123 } 
+	týu_£t_t
+;
+
+126 #ià
+	`__GNUC_PREREQ
+ (2, 91)
+
+127 

+	#__CPU_ZERO_S
+(
+£tsize
+, 
+ýu£�
+) \
+
+128 dØ
+	`__bužtš_mem£t
+ (
+ýu£�
+, '\0', 
+£tsize
+); 0)
+
+	)
+
+130 

+	#__CPU_ZERO_S
+(
+£tsize
+, 
+ýu£�
+) \
+
+132 
+size_t
+ 
+__i
+; \
+
+133 
+size_t
+ 
+__imax
+ = (
+£tsize
+è/  (
+__ýu_mask
+); \
+
+134 
+__ýu_mask
+ *
+__b™s
+ = (
+ýu£�
+)->__bits; \
+
+135 
+__i
+ = 0; __˜< 
+__imax
+; ++__i) \
+
+136 
+__b™s
+[
+__i
+] = 0; \
+
+137 
+	}
+} 0)
+
+	)
+
+139 

+	#__CPU_SET_S
+(
+ýu
+, 
+£tsize
+, 
+ýu£�
+) \
+
+140 (
+__ex‹nsiÚ__
+ \
+
+141 ({ 
+size_t
+ 
+__ýu
+ = (
+ýu
+); \
+
+142 
+__ýu
+ < 8 * (
+£tsize
+) \
+
+143 ? (((
+__ýu_mask
+ *è((
+ýu£�
+)->
+__b™s
+))[
+	`__CPUELT
+ (
+__ýu
+)] \
+
+144 |ð
+	`__CPUMASK
+ (
+__ýu
+)) \
+
+145 : 0; }))
+
+	)
+
+146 

+	#__CPU_CLR_S
+(
+ýu
+, 
+£tsize
+, 
+ýu£�
+) \
+
+147 (
+__ex‹nsiÚ__
+ \
+
+148 ({ 
+size_t
+ 
+__ýu
+ = (
+ýu
+); \
+
+149 
+__ýu
+ < 8 * (
+£tsize
+) \
+
+150 ? (((
+__ýu_mask
+ *è((
+ýu£�
+)->
+__b™s
+))[
+	`__CPUELT
+ (
+__ýu
+)] \
+
+151 &ð~
+	`__CPUMASK
+ (
+__ýu
+)) \
+
+152 : 0; }))
+
+	)
+
+153 

+	#__CPU_ISSET_S
+(
+ýu
+, 
+£tsize
+, 
+ýu£�
+) \
+
+154 (
+__ex‹nsiÚ__
+ \
+
+155 ({ 
+size_t
+ 
+__ýu
+ = (
+ýu
+); \
+
+156 
+__ýu
+ < 8 * (
+£tsize
+) \
+
+157 ? ((((
+__cÚ¡
+ 
+__ýu_mask
+ *è((
+ýu£�
+)->
+__b™s
+))[
+	`__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
+, 
+ýu£�1
+, 
+ýu£�2
+) \
+
+166 (
+	`__bužtš_memcmp
+ (
+ýu£�1
+, 
+ýu£�2
+, 
+£tsize
+è=ð0)
+
+	)
+
+168 

+	#__CPU_EQUAL_S
+(
+£tsize
+, 
+ýu£�1
+, 
+ýu£�2
+) \
+
+169 (
+__ex‹nsiÚ__
+ \
+
+170 ({ 
+__cÚ¡
+ 
+__ýu_mask
+ *
+__¬r1
+ = (
+ýu£�1
+)->
+__b™s
+; \
+
+171 
+__cÚ¡
+ 
+__ýu_mask
+ *
+__¬r2
+ = (
+ýu£�2
+)->
+__b™s
+; \
+
+172 
+size_t
+ 
+__imax
+ = (
+£tsize
+è/  (
+__ýu_mask
+); \
+
+173 
+size_t
+ 
+__i
+; \
+
+174 
+__i
+ = 0; __˜< 
+__imax
+; ++__i) \
+
+175 ià(
+__b™s
+[
+__i
+] != __bits[__i]) \
+
+177 
+__i
+ =ð
+__imax
+; }))
+
+	)
+
+180 

+	#__CPU_OP_S
+(
+£tsize
+, 
+de¡£t
+, 
+¤c£t1
+, 
+¤c£t2
+, 
+Ý
+) \
+
+181 (
+__ex‹nsiÚ__
+ \
+
+182 ({ 
+ýu_£t_t
+ *
+__de¡
+ = (
+de¡£t
+); \
+
+183 
+__cÚ¡
+ 
+__ýu_mask
+ *
+__¬r1
+ = (
+¤c£t1
+)->
+__b™s
+; \
+
+184 
+__cÚ¡
+ 
+__ýu_mask
+ *
+__¬r2
+ = (
+¤c£t2
+)->
+__b™s
+; \
+
+185 
+size_t
+ 
+__imax
+ = (
+£tsize
+è/  (
+__ýu_mask
+); \
+
+186 
+size_t
+ 
+__i
+; \
+
+187 
+__i
+ = 0; __˜< 
+__imax
+; ++__i) \
+
+188 ((
+__ýu_mask
+ *è
+__de¡
+->
+__b™s
+)[
+__i
+] = 
+__¬r1
+[__i] 
+Ý
+ 
+__¬r2
+[__i]; \
+
+189 
+__de¡
+; }))
+
+	)
+
+191 

+	#__CPU_ALLOC_SIZE
+(
+couÁ
+) \
+
+192 ((((
+couÁ
+è+ 
+__NCPUBITS
+ - 1è/ __NCPUBITSè*  (
+__ýu_mask
+))
+
+	)
+
+193 

+	#__CPU_ALLOC
+(
+couÁ
+è
+	`__sched_ýu®loc
+ (couÁ)
+
+	)
+
+194 

+	#__CPU_FREE
+(
+ýu£t
+è
+	`__sched_ýuä“
+ (ýu£t)
+
+	)
+
+196 
+__BEGIN_DECLS
+
+
+198 

+	$__sched_ýucouÁ
+ (
+size_t
+ 
+__£tsize
+, cÚ¡ 
+ýu_£t_t
+ *
+__£�
+)
+
+199 
+__THROW
+;
+
+200 

+ýu_£t_t
+ *
+	$__sched_ýu®loc
+ (
+size_t
+ 
+__couÁ
+è
+__THROW
+ 
+__wur
+;
+
+201 

+	$__sched_ýuä“
+ (
+ýu_£t_t
+ *
+__£t
+è
+__THROW
+;
+
+203 
+__END_DECLS
+
+
+	@/usr/include/bits/sigaction.h
+
+20 #iâdeà
+_SIGNAL_H
+
+
+25 
+	ssigaùiÚ
+
+
+28 #ifdeà
+__USE_POSIX199309
+
+
+32 
+__sighªdËr_t
+ 
+	m§_hªdËr
+;
+
+34 (*
+	m§_sigaùiÚ
+è(, 
+	msigšfo_t
+ *, *);
+
+36 
+	m__sigaùiÚ_hªdËr
+;
+
+37 

+	#§_hªdËr
+ 
+__sigaùiÚ_hªdËr
+.
+§_hªdËr
+
+
+	)
+
+38 

+	#§_sigaùiÚ
+ 
+__sigaùiÚ_hªdËr
+.
+§_sigaùiÚ
+
+
+	)
+
+40 
+__sighªdËr_t
+ 
+	m§_hªdËr
+;
+
+44 
+__sig£t_t
+ 
+	m§_mask
+;
+
+47 
+	m§_æags
+;
+
+50 (*
+	m§_»¡Ü”
+) ();
+
+54 

+	#SA_NOCLDSTOP
+ 1
+
+	)
+
+55 

+	#SA_NOCLDWAIT
+ 2
+
+	)
+
+56 

+	#SA_SIGINFO
+ 4
+
+	)
+
+58 #ià
+defšed
+ 
+__USE_UNIX98
+ || defšed 
+__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 #iâdeà
+_BITS_SIGCONTEXT_H
+
+
+20 

+	#_BITS_SIGCONTEXT_H
+ 1
+
+	)
+
+22 #ià!
+defšed
+ 
+_SIGNAL_H
+ && !defšed 
+_SYS_UCONTEXT_H
+
+
+26 
+	~<b™s/wÜdsize.h
+>
+
+28 
+	s_å»g
+
+
+30 
+	msignifiÿnd
+[4];
+
+31 
+	mexpÚ’t
+;
+
+34 
+	s_åx»g
+
+
+36 
+	msignifiÿnd
+[4];
+
+37 
+	mexpÚ’t
+;
+
+38 
+	m·ddšg
+[3];
+
+41 
+	s_xmm»g
+
+
+43 
+__ušt32_t
+ 
+	m–em’t
+[4];
+
+48 #ià
+__WORDSIZE
+ == 32
+
+50 
+	s_å¡©e
+
+
+53 
+__ušt32_t
+ 
+	mcw
+;
+
+54 
+__ušt32_t
+ 
+	msw
+;
+
+55 
+__ušt32_t
+ 
+	m�g
+;
+
+56 
+__ušt32_t
+ 
+	m�off
+;
+
+57 
+__ušt32_t
+ 
+	mcs£l
+;
+
+58 
+__ušt32_t
+ 
+	md©aoff
+;
+
+59 
+__ušt32_t
+ 
+	md©a£l
+;
+
+60 
+_å»g
+ 
+	m_¡
+[8];
+
+61 
+	m¡©us
+;
+
+62 
+	mmagic
+;
+
+65 
+__ušt32_t
+ 
+	m_fx¤_’v
+[6];
+
+66 
+__ušt32_t
+ 
+	mmxc¤
+;
+
+67 
+__ušt32_t
+ 
+	mȣrved
+;
+
+68 
+_åx»g
+ 
+	m_fx¤_¡
+[8];
+
+69 
+_xmm»g
+ 
+	m_xmm
+[8];
+
+70 
+__ušt32_t
+ 
+	m·ddšg
+[56];
+
+73 #iâdeà
+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 
+	m—x
+;
+
+95 
+	mŒ­no
+;
+
+96 
+	m”r
+;
+
+97 
+	me�
+;
+
+98 
+	mcs
+, 
+	m__csh
+;
+
+99 
+	meæags
+;
+
+100 
+	me¥_©_sigÇl
+;
+
+101 
+	mss
+, 
+	m__ssh
+;
+
+102 
+_å¡©e
+ * 
+	må¡©e
+;
+
+103 
+	mÞdmask
+;
+
+104 
+	mü2
+;
+
+109 
+	s_å¡©e
+
+
+112 
+__ušt16_t
+ 
+	mcwd
+;
+
+113 
+__ušt16_t
+ 
+	mswd
+;
+
+114 
+__ušt16_t
+ 
+	máw
+;
+
+115 
+__ušt16_t
+ 
+	mfÝ
+;
+
+116 
+__ušt64_t
+ 
+	mr�
+;
+
+117 
+__ušt64_t
+ 
+	mrdp
+;
+
+118 
+__ušt32_t
+ 
+	mmxc¤
+;
+
+119 
+__ušt32_t
+ 
+	mmxü_mask
+;
+
+120 
+_åx»g
+ 
+	m_¡
+[8];
+
+121 
+_xmm»g
+ 
+	m_xmm
+[16];
+
+122 
+__ušt32_t
+ 
+	m·ddšg
+[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 
+	m¿x
+;
+
+141 
+	mrcx
+;
+
+142 
+	mr¥
+;
+
+143 
+	mr�
+;
+
+144 
+	meæags
+;
+
+145 
+	mcs
+;
+
+146 
+	mgs
+;
+
+147 
+	mfs
+;
+
+148 
+	m__·d0
+;
+
+149 
+	m”r
+;
+
+150 
+	mŒ­no
+;
+
+151 
+	mÞdmask
+;
+
+152 
+	mü2
+;
+
+153 
+_å¡©e
+ * 
+	må¡©e
+;
+
+154 
+	m__ȣrved1
+ [8];
+
+	@/usr/include/bits/siginfo.h
+
+20 #ià!
+defšed
+ 
+_SIGNAL_H
+ && !defšed 
+__Ãed_sigšfo_t
+ \
+
+21 && !
+defšed
+ 
+	g__Ãed_sigev’t_t
+
+
+25 
+	~<b™s/wÜdsize.h
+>
+
+27 #ià(!
+defšed
+ 
+__have_sigv®_t
+ \
+
+28 && (
+defšed
+ 
+	g_SIGNAL_H
+ || defšed 
+	g__Ãed_sigšfo_t
+ \
+
+29 || 
+defšed
+ 
+	g__Ãed_sigev’t_t
+))
+
+30 

+	#__have_sigv®_t
+ 1
+
+	)
+
+33 
+	usigv®
+
+
+35 
+	msiv®_št
+;
+
+36 *
+	msiv®_±r
+;
+
+37 } 
+	tsigv®_t
+;
+
+40 #ià(!
+defšed
+ 
+__have_sigšfo_t
+ \
+
+41 && (
+defšed
+ 
+	g_SIGNAL_H
+ || defšed 
+	g__Ãed_sigšfo_t
+))
+
+42 

+	#__have_sigšfo_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 
+	ssigšfo
+
+
+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_kžl
+;
+
+72 
+	msi_tid
+;
+
+73 
+	msi_ov”run
+;
+
+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_sigçuÉ
+;
+
+104 
+	msi_bªd
+;
+
+105 
+	msi_fd
+;
+
+106 } 
+	m_sigpÞl
+;
+
+107 } 
+	m_sif›lds
+;
+
+108 } 
+	tsigšfo_t
+;
+
+112 

+	#si_pid
+ 
+_sif›lds
+.
+_kžl
+.
+si_pid
+
+
+	)
+
+113 

+	#si_uid
+ 
+_sif›lds
+.
+_kžl
+.
+si_uid
+
+
+	)
+
+114 

+	#si_tim”id
+ 
+_sif›lds
+.
+_tim”
+.
+si_tid
+
+
+	)
+
+115 

+	#si_ov”run
+ 
+_sif›lds
+.
+_tim”
+.
+si_ov”run
+
+
+	)
+
+116 

+	#si_¡©us
+ 
+_sif›lds
+.
+_sigchld
+.
+si_¡©us
+
+
+	)
+
+117 

+	#si_utime
+ 
+_sif›lds
+.
+_sigchld
+.
+si_utime
+
+
+	)
+
+118 

+	#si_¡ime
+ 
+_sif›lds
+.
+_sigchld
+.
+si_¡ime
+
+
+	)
+
+119 

+	#si_v®ue
+ 
+_sif›lds
+.
+_¹
+.
+si_sigv®
+
+
+	)
+
+120 

+	#si_št
+ 
+_sif›lds
+.
+_¹
+.
+si_sigv®
+.
+siv®_št
+
+
+	)
+
+121 

+	#si_±r
+ 
+_sif›lds
+.
+_¹
+.
+si_sigv®
+.
+siv®_±r
+
+
+	)
+
+122 

+	#si_addr
+ 
+_sif›lds
+.
+_sigçuÉ
+.
+si_addr
+
+
+	)
+
+123 

+	#si_bªd
+ 
+_sif›lds
+.
+_sigpÞl
+.
+si_bªd
+
+
+	)
+
+124 

+	#si_fd
+ 
+_sif›lds
+.
+_sigpÞl
+.
+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_sigšfo_t
+
+
+261 #ià(
+defšed
+ 
+_SIGNAL_H
+ || defšed 
+__Ãed_sigev’t_t
+) \
+
+262 && !
+defšed
+ 
+	g__have_sigev’t_t
+
+
+263 

+	#__have_sigev’t_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 
+	ssigev’t
+
+
+275 
+sigv®_t
+ 
+	msigev_v®ue
+;
+
+276 
+	msigev_signo
+;
+
+277 
+	msigev_nÙify
+;
+
+281 
+	m_·d
+[
+__SIGEV_PAD_SIZE
+];
+
+285 
+__pid_t
+ 
+	m_tid
+;
+
+289 (*
+	m_funùiÚ
+è(
+	msigv®_t
+);
+
+290 *
+	m_©Œibu‹
+;
+
+291 } 
+	m_sigev_th»ad
+;
+
+292 } 
+	m_sigev_un
+;
+
+293 } 
+	tsigev’t_t
+;
+
+296 

+	#sigev_nÙify_funùiÚ
+ 
+_sigev_un
+.
+_sigev_th»ad
+.
+_funùiÚ
+
+
+	)
+
+297 

+	#sigev_nÙify_©Œibu‹s
+ 
+_sigev_un
+.
+_sigev_th»ad
+.
+_©Œ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
+ ((
+__sighªdËr_t
+è-1è
+
+	)
+
+24 

+	#SIG_DFL
+ ((
+__sighªdËr_t
+è0è
+
+	)
+
+25 

+	#SIG_IGN
+ ((
+__sighªdËr_t
+è1è
+
+	)
+
+27 #ifdeà
+__USE_UNIX98
+
+
+28 

+	#SIG_HOLD
+ ((
+__sighªdËr_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_cu¼’t_sig¹mš
+ ())
+
+	)
+
+73 

+	#SIGRTMAX
+ (
+	`__libc_cu¼’t_sig¹max
+ ())
+
+	)
+
+77 

+	#__SIGRTMIN
+ 32
+
+	)
+
+78 

+	#__SIGRTMAX
+ (
+_NSIG
+ - 1)
+
+	)
+
+	@/usr/include/bits/sigset.h
+
+21 #iâdef 
+_SIGSET_H_ty³s
+
+
+22 

+	#_SIGSET_H_ty³s
+ 1
+
+	)
+
+24 
+	t__sig_©omic_t
+;
+
+28 

+	#_SIGSET_NWORDS
+ (1024 / (8 *  ()))
+
+	)
+
+31 
+	m__v®
+[
+_SIGSET_NWORDS
+];
+
+32 } 
+	t__sig£t_t
+;
+
+43 #ià!
+defšed
+ 
+_SIGSET_H_âs
+ && defšed 
+_SIGNAL_H
+
+
+44 

+	#_SIGSET_H_âs
+ 1
+
+	)
+
+46 #iâdeà
+_EXTERN_INLINE
+
+
+47 

+	#_EXTERN_INLINE
+ 
+__ex‹º_šlše
+
+
+	)
+
+51 

+	#__sigmask
+(
+sig
+) \
+
+52 (((è1è<< (((
+sig
+è- 1è% (8 *  ())))
+
+	)
+
+55 

+	#__sigwÜd
+(
+sig
+è(((sigè- 1è/ (8 *  ()))
+
+	)
+
+57 #ià
+defšed
+ 
+__GNUC__
+ && __GNUC__ >= 2
+
+58 

+	#__sigem±y£t
+(
+£t
+) \
+
+59 (
+	`__ex‹nsiÚ__
+ ({ 
+__út
+ = 
+_SIGSET_NWORDS
+; \
+
+60 
+sig£t_t
+ *
+__£t
+ = (
+£t
+); \
+
+61 --
+__út
+ >ð0è
+__£t
+->
+__v®
+[__cnt] = 0; \
+
+62 0; }))
+
+	)
+
+63 

+	#__sigfžl£t
+(
+£t
+) \
+
+64 (
+	`__ex‹nsiÚ__
+ ({ 
+__út
+ = 
+_SIGSET_NWORDS
+; \
+
+65 
+sig£t_t
+ *
+__£t
+ = (
+£t
+); \
+
+66 --
+__út
+ >ð0è
+__£t
+->
+__v®
+[__cnt] = ~0UL; \
+
+67 0; }))
+
+	)
+
+69 #ifdeà
+__USE_GNU
+
+
+73 

+	#__sigi£m±y£t
+(
+£t
+) \
+
+74 (
+	`__ex‹nsiÚ__
+ ({ 
+__út
+ = 
+_SIGSET_NWORDS
+; \
+
+75 cÚ¡ 
+sig£t_t
+ *
+__£t
+ = (
+£t
+); \
+
+76 
+__»t
+ = 
+__£t
+->
+__v®
+[--
+__út
+]; \
+
+77 !
+__»t
+ && --
+__út
+ >= 0) \
+
+78 
+__»t
+ = 
+__£t
+->
+__v®
+[
+__út
+]; \
+
+79 
+__»t
+ =ð0; }))
+
+	)
+
+80 

+	#__sigªd£t
+(
+de¡
+, 
+Ëá
+, 
+right
+) \
+
+81 (
+	`__ex‹nsiÚ__
+ ({ 
+__út
+ = 
+_SIGSET_NWORDS
+; \
+
+82 
+sig£t_t
+ *
+__de¡
+ = (
+de¡
+); \
+
+83 cÚ¡ 
+sig£t_t
+ *
+__Ëá
+ = (
+Ëá
+); \
+
+84 cÚ¡ 
+sig£t_t
+ *
+__right
+ = (
+right
+); \
+
+85 --
+__út
+ >= 0) \
+
+86 
+__de¡
+->
+__v®
+[
+__út
+] = (
+__Ëá
+->__val[__cnt] \
+
+87 & 
+__right
+->
+__v®
+[
+__út
+]); \
+
+88 0; }))
+
+	)
+
+89 

+	#__sigܣt
+(
+de¡
+, 
+Ëá
+, 
+right
+) \
+
+90 (
+	`__ex‹nsiÚ__
+ ({ 
+__út
+ = 
+_SIGSET_NWORDS
+; \
+
+91 
+sig£t_t
+ *
+__de¡
+ = (
+de¡
+); \
+
+92 cÚ¡ 
+sig£t_t
+ *
+__Ëá
+ = (
+Ëá
+); \
+
+93 cÚ¡ 
+sig£t_t
+ *
+__right
+ = (
+right
+); \
+
+94 --
+__út
+ >= 0) \
+
+95 
+__de¡
+->
+__v®
+[
+__út
+] = (
+__Ëá
+->__val[__cnt] \
+
+96 | 
+__right
+->
+__v®
+[
+__út
+]); \
+
+97 0; }))
+
+	)
+
+104 

+__sigismemb”
+ (
+__cÚ¡
+ 
+__sig£t_t
+ *, );
+
+105 

+__sigadd£t
+ (
+__sig£t_t
+ *, );
+
+106 

+__sigd–£t
+ (
+__sig£t_t
+ *, );
+
+108 #ifdeà
+__USE_EXTERN_INLINES
+
+
+109 

+	#__SIGSETFN
+(
+NAME
+, 
+BODY
+, 
+CONST
+) \
+
+110 
+_EXTERN_INLINE
+ \
+
+111 
+	`NAME
+ (
+CONST
+ 
+__sig£t_t
+ *
+__£t
+, 
+__sig
+) \
+
+113 
+__mask
+ = 
+	`__sigmask
+ (
+__sig
+); \
+
+114 
+__wÜd
+ = 
+	`__sigwÜd
+ (
+__sig
+); \
+
+115  
+BODY
+; \
+
+116 }
+
+	)
+
+118 
+__SIGSETFN
+ (
+__sigismemb”
+, (
+__£t
+->
+__v®
+[
+__wÜd
+] & 
+__mask
+è? 1 : 0, 
+__cÚ¡
+)
+
+119 
+__SIGSETFN
+ (
+__sigadd£t
+, ((
+__£t
+->
+__v®
+[
+__wÜd
+] |ð
+__mask
+), 0), )
+
+120 
+__SIGSETFN
+ (
+__sigd–£t
+, ((
+__£t
+->
+__v®
+[
+__wÜd
+] &ð~
+__mask
+), 0), )
+
+122 #undeà
+__SIGSETFN
+
+
+	@/usr/include/bits/sigstack.h
+
+20 #iâdeà
+_SIGNAL_H
+
+
+26 
+	ssig¡ack
+
+
+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 
+	ssig®t¡ack
+
+
+52 *
+	mss_¥
+;
+
+53 
+	mss_æags
+;
+
+54 
+size_t
+ 
+	mss_size
+;
+
+55 } 
+	t¡ack_t
+;
+
+	@/usr/include/bits/sigthread.h
+
+20 #iâdeà
+_BITS_SIGTHREAD_H
+
+
+21 

+	#_BITS_SIGTHREAD_H
+ 1
+
+	)
+
+23 #ià!
+defšed
+ 
+_SIGNAL_H
+ && !defšed 
+_PTHREAD_H
+
+
+31 

+	$±h»ad_sigmask
+ (
+__how
+,
+
+32 
+__cÚ¡
+ 
+__sig£t_t
+ *
+__»¡riù
+ 
+__Ãwmask
+,
+
+33 
+__sig£t_t
+ *
+__»¡riù
+ 
+__Þdmask
+)
+__THROW
+;
+
+36 

+	$±h»ad_kžl
+ (
+±h»ad_t
+ 
+__th»adid
+, 
+__signo
+è
+__THROW
+;
+
+38 #ifdeà
+__USE_GNU
+
+
+40 

+	$±h»ad_sigqueue
+ (
+±h»ad_t
+ 
+__th»adid
+, 
+__signo
+,
+
+41 cÚ¡ 
+sigv®
+ 
+__v®ue
+è
+__THROW
+;
+
+	@/usr/include/bits/time.h
+
+24 #iâdeà
+__Ãed_timev®
+
+
+25 #iâdeà
+_BITS_TIME_H
+
+
+26 

+	#_BITS_TIME_H
+ 1
+
+	)
+
+34 

+	#CLOCKS_PER_SEC
+ 1000000l
+
+	)
+
+36 #ià!
+defšed
+ 
+__STRICT_ANSI__
+ && !defšed 
+__USE_XOPEN2K
+
+
+39 
+	~<b™s/ty³s.h
+>
+
+40 

+__syscÚf
+ ();
+
+41 

+	#CLK_TCK
+ ((
+__þock_t
+è
+	`__syscÚf
+ (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 #iâdeà
+_STRUCT_TIMEVAL
+
+
+64 

+	#_STRUCT_TIMEVAL
+ 1
+
+	)
+
+65 
+	~<b™s/ty³s.h
+>
+
+69 
+	stimev®
+
+
+71 
+__time_t
+ 
+	mtv_£c
+;
+
+72 
+__su£cÚds_t
+ 
+	mtv_u£c
+;
+
+	@/usr/include/linux/errno.h
+
+1 #iâdeà
+_LINUX_ERRNO_H
+
+
+2 

+	#_LINUX_ERRNO_H
+
+
+	)
+
+4 
+	~<asm/Ӽo.h
+>
+
+	@/usr/include/sys/ucontext.h
+
+19 #iâdeà
+_SYS_UCONTEXT_H
+
+
+20 

+	#_SYS_UCONTEXT_H
+ 1
+
+	)
+
+22 
+	~<ã©u»s.h
+>
+
+23 
+	~<sigÇl.h
+>
+
+24 
+	~<b™s/wÜdsize.h
+>
+
+28 
+	~<b™s/sigcÚ‹xt.h
+>
+
+30 #ià
+__WORDSIZE
+ == 64
+
+33 
+	tg»g_t
+;
+
+36 

+	#NGREG
+ 23
+
+	)
+
+39 
+g»g_t
+ 
+	tg»g£t_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_åx»g
+
+
+96 
+	msignifiÿnd
+[4];
+
+97 
+	mexpÚ’t
+;
+
+98 
+	m·ddšg
+[3];
+
+101 
+	s_libc_xmm»g
+
+
+103 
+__ušt32_t
+ 
+	m–em’t
+[4];
+
+106 
+	s_libc_å¡©e
+
+
+109 
+__ušt16_t
+ 
+	mcwd
+;
+
+110 
+__ušt16_t
+ 
+	mswd
+;
+
+111 
+__ušt16_t
+ 
+	máw
+;
+
+112 
+__ušt16_t
+ 
+	mfÝ
+;
+
+113 
+__ušt64_t
+ 
+	mr�
+;
+
+114 
+__ušt64_t
+ 
+	mrdp
+;
+
+115 
+__ušt32_t
+ 
+	mmxc¤
+;
+
+116 
+__ušt32_t
+ 
+	mmxü_mask
+;
+
+117 
+_libc_åx»g
+ 
+	m_¡
+[8];
+
+118 
+_libc_xmm»g
+ 
+	m_xmm
+[16];
+
+119 
+__ušt32_t
+ 
+	m·ddšg
+[24];
+
+123 
+_libc_å¡©e
+ *
+	tå»g£t_t
+;
+
+128 
+g»g£t_t
+ 
+	mg»gs
+;
+
+130 
+å»g£t_t
+ 
+	må»gs
+;
+
+131 
+	m__ȣrved1
+ [8];
+
+132 } 
+	tmcÚ‹xt_t
+;
+
+135 
+	sucÚ‹xt
+
+
+137 
+	muc_æags
+;
+
+138 
+ucÚ‹xt
+ *
+	muc_lšk
+;
+
+139 
+¡ack_t
+ 
+	muc_¡ack
+;
+
+140 
+mcÚ‹xt_t
+ 
+	muc_mcÚ‹xt
+;
+
+141 
+__sig£t_t
+ 
+	muc_sigmask
+;
+
+142 
+_libc_å¡©e
+ 
+	m__å»gs_mem
+;
+
+143 } 
+	tucÚ‹xt_t
+;
+
+148 
+	tg»g_t
+;
+
+151 

+	#NGREG
+ 19
+
+	)
+
+154 
+g»g_t
+ 
+	tg»g£t_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 
+	msignifiÿnd
+[4];
+
+205 
+	mexpÚ’t
+;
+
+208 
+	s_libc_å¡©e
+
+
+210 
+	mcw
+;
+
+211 
+	msw
+;
+
+212 
+	m�g
+;
+
+213 
+	m�off
+;
+
+214 
+	mcs£l
+;
+
+215 
+	md©aoff
+;
+
+216 
+	md©a£l
+;
+
+217 
+_libc_å»g
+ 
+	m_¡
+[8];
+
+218 
+	m¡©us
+;
+
+222 
+_libc_å¡©e
+ *
+	tå»g£t_t
+;
+
+227 
+g»g£t_t
+ 
+	mg»gs
+;
+
+230 
+å»g£t_t
+ 
+	må»gs
+;
+
+231 
+	mÞdmask
+;
+
+232 
+	mü2
+;
+
+233 } 
+	tmcÚ‹xt_t
+;
+
+236 
+	sucÚ‹xt
+
+
+238 
+	muc_æags
+;
+
+239 
+ucÚ‹xt
+ *
+	muc_lšk
+;
+
+240 
+¡ack_t
+ 
+	muc_¡ack
+;
+
+241 
+mcÚ‹xt_t
+ 
+	muc_mcÚ‹xt
+;
+
+242 
+__sig£t_t
+ 
+	muc_sigmask
+;
+
+243 
+_libc_å¡©e
+ 
+	m__å»gs_mem
+;
+
+244 } 
+	tucÚ‹xt_t
+;
+
+	@/usr/include/asm/errno.h
+
+1 
+	~<asm-g’”ic/”ºo.h
+>
+
+	@/usr/include/asm-generic/errno.h
+
+1 #iâdeà
+_ASM_GENERIC_ERRNO_H
+
+
+2 

+	#_ASM_GENERIC_ERRNO_H
+
+
+	)
+
+4 
+	~<asm-g’”ic/”ºo-ba£.h
+>
+
+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 #iâdeà
+_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 <omega.h>
+#include <code_gen/CG_outputBuilder.h>
+#include <code_gen/CG_outputRepr.h>
+#include <vector>
+#include <set>
+
+namespace omega {
+extern int last_level;
+
+CG_outputRepr* outputIdent(CG_outputBuilder* ocg, const Relation &R, Variable_ID v, const std::vector<CG_outputRepr *> &assigned_on_the_fly);
+std::pair<CG_outputRepr *, bool> outputAssignment(CG_outputBuilder *ocg, const Relation &R_, Variable_ID v, Relation &enforced, CG_outputRepr *&if_repr, const std::vector<CG_outputRepr *> &assigned_on_the_fly);
+std::pair<CG_outputRepr *, bool> outputBounds(CG_outputBuilder* ocg, const Relation &bounds, Variable_ID v, int indent, Relation &enforced, const std::vector<CG_outputRepr *> &assigned_on_the_fly);
+Tuple<CG_outputRepr*> outputSubstitution(CG_outputBuilder* ocg, const Relation &R, const std::vector<CG_outputRepr *> &assigned_on_the_fly);
+CG_outputRepr* outputStatement(CG_outputBuilder* ocg, CG_outputRepr *stmt, int indent,  const Relation &mapping, const Relation &known, const std::vector<CG_outputRepr *> &assigned_on_the_fly);
+CG_outputRepr* outputGuard(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &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<CG_outputRepr *> &assigned_on_the_fly);
+CG_outputRepr* output_EQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &assigned_on_the_fly);
+CG_outputRepr* output_GEQ_strides(CG_outputBuilder* ocg, const Relation &guards_in, const std::vector<CG_outputRepr *> &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<CG_outputRepr *> &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<CG_outputRepr *> &assigned_on_the_fly = std::vector<CG_outputRepr *>(last_level, static_cast<CG_outputRepr *>(NULL)));
+CG_outputRepr* outputEasyBoundAsRepr(CG_outputBuilder* ocg, Relation &bounds, const Constraint_Handle &g, Variable_ID v, bool ignoreWC, int ceiling, const std::vector<CG_outputRepr *> &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<Relation> &I, const Tuple<int> &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 <algorithm>
+#include <string>
+#include <vector>
+
+namespace omega {
+
+class CodeInsertion;
+
+typedef std::vector<CodeInsertion*> CodeInsertionPtrList;
+typedef std::vector<CodeInsertion*>::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<std::string*> indecies;
+	std::vector<int> 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<CodeInsertion*> code_insertions;
+public:
+	CodeInsertionAttribute() { code_insertions = std::vector<CodeInsertion*>(); }
+	~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<CodeInsertionMark*> 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