struct _IO_FILE;
struct _IO_FILE *_coverage_fout ;
typedef struct _IO_FILE FILE;
extern int fflush(FILE *__stream ) ;
extern int fprintf(FILE * __restrict  __stream ,
                   char const   * __restrict  __format  , ...) ;
struct _zval_struct;
typedef struct _zval_struct zval;
typedef unsigned char zend_uchar;
typedef unsigned int zend_uint;
struct _zend_object_handlers;
typedef struct _zend_object_handlers zend_object_handlers;
typedef unsigned int zend_object_handle;
struct _zend_object_value {
   zend_object_handle handle ;
   zend_object_handlers *handlers ;
};
typedef struct _zend_object_value zend_object_value;
struct _hashtable;
typedef struct _hashtable HashTable;
struct __anonstruct_str_39 {
   char *val ;
   int len ;
};
union _zvalue_value {
   long lval ;
   double dval ;
   struct __anonstruct_str_39 str ;
   HashTable *ht ;
   zend_object_value obj ;
};
typedef union _zvalue_value zvalue_value;
struct _zval_struct {
   zvalue_value value ;
   zend_uint refcount__gc ;
   zend_uchar type ;
   zend_uchar is_ref__gc ;
};
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  php_error_docref0)(char const   *docref ,
                                                                                                     int type ,
                                                                                                     char const   *format 
                                                                                                     , ...) ;
struct _zend_class_entry;
typedef struct _zend_class_entry zend_class_entry;
struct _dom_object;
typedef struct _dom_object dom_object;
struct _php_libxml_ref_obj;
typedef struct _php_libxml_ref_obj php_libxml_ref_obj;
struct _zend_object {
   zend_class_entry *ce ;
   HashTable *properties ;
   zval **properties_table ;
   HashTable *guards ;
};
typedef struct _zend_object zend_object;
struct _dom_object {
   zend_object std ;
   void *ptr ;
   php_libxml_ref_obj *document ;
   HashTable *prop_handler ;
   zend_object_handle handle ;
};
extern int dom_set_doc_classmap(php_libxml_ref_obj *document ,
                                zend_class_entry *basece , zend_class_entry *ce ) ;
struct _zend_module_entry;
struct _zend_function_entry;
struct __anonstruct_internal_42 {
   struct _zend_function_entry  const  *builtin_functions ;
   struct _zend_module_entry *module ;
};
struct __anonstruct_user_41 {
   char *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char *doc_comment ;
   zend_uint doc_comment_len ;
};
union __anonunion_info_40 {
   struct __anonstruct_user_41 user ;
   struct __anonstruct_internal_42 internal ;
};
struct _zend_trait_precedence;
typedef struct _zend_trait_precedence zend_trait_precedence;
struct _zend_trait_alias;
typedef struct _zend_trait_alias zend_trait_alias;
struct _zend_unserialize_data;
typedef struct _zend_unserialize_data zend_unserialize_data;
struct _zend_serialize_data;
typedef struct _zend_serialize_data zend_serialize_data;
union _zend_function;
struct _zend_object_iterator;
typedef struct _zend_object_iterator zend_object_iterator;
struct _zend_object_iterator_funcs;
typedef struct _zend_object_iterator_funcs zend_object_iterator_funcs;
struct _zend_class_iterator_funcs {
   zend_object_iterator_funcs *funcs ;
   union _zend_function *zf_new_iterator ;
   union _zend_function *zf_valid ;
   union _zend_function *zf_current ;
   union _zend_function *zf_key ;
   union _zend_function *zf_next ;
   union _zend_function *zf_rewind ;
};
typedef struct _zend_class_iterator_funcs zend_class_iterator_funcs;
typedef unsigned char zend_bool;
struct bucket;
typedef struct bucket Bucket;
typedef unsigned long ulong;
typedef unsigned int uint;
struct _hashtable {
   uint nTableSize ;
   uint nTableMask ;
   uint nNumOfElements ;
   ulong nNextFreeElement ;
   Bucket *pInternalPointer ;
   Bucket *pListHead ;
   Bucket *pListTail ;
   Bucket **arBuckets ;
   void (*pDestructor)(void *pDest ) ;
   zend_bool persistent ;
   unsigned char nApplyCount ;
   zend_bool bApplyProtection ;
};
struct _zend_class_entry {
   char type ;
   char const   *name ;
   zend_uint name_length ;
   struct _zend_class_entry *parent ;
   int refcount ;
   zend_uint ce_flags ;
   HashTable function_table ;
   HashTable properties_info ;
   zval **default_properties_table ;
   zval **default_static_members_table ;
   zval **static_members_table ;
   HashTable constants_table ;
   int default_properties_count ;
   int default_static_members_count ;
   union _zend_function *constructor ;
   union _zend_function *destructor ;
   union _zend_function *clone ;
   union _zend_function *__get ;
   union _zend_function *__set ;
   union _zend_function *__unset ;
   union _zend_function *__isset ;
   union _zend_function *__call ;
   union _zend_function *__callstatic ;
   union _zend_function *__tostring ;
   union _zend_function *serialize_func ;
   union _zend_function *unserialize_func ;
   zend_class_iterator_funcs iterator_funcs ;
   zend_object_value (*create_object)(zend_class_entry *class_type ) ;
   zend_object_iterator *(*get_iterator)(zend_class_entry *ce , zval *object ,
                                         int by_ref ) ;
   int (*interface_gets_implemented)(zend_class_entry *iface ,
                                     zend_class_entry *class_type ) ;
   union _zend_function *(*get_static_method)(zend_class_entry *ce ,
                                              char *method , int method_len ) ;
   int (*serialize)(zval *object , unsigned char **buffer , zend_uint *buf_len ,
                    zend_serialize_data *data ) ;
   int (*unserialize)(zval **object , zend_class_entry *ce ,
                      unsigned char const   *buf , zend_uint buf_len ,
                      zend_unserialize_data *data ) ;
   zend_class_entry **interfaces ;
   zend_uint num_interfaces ;
   zend_class_entry **traits ;
   zend_uint num_traits ;
   zend_trait_alias **trait_aliases ;
   zend_trait_precedence **trait_precedences ;
   union __anonunion_info_40 info ;
};
struct _xmlDoc;
typedef struct _xmlDoc xmlDoc;
struct _php_libxml_node_ptr;
typedef struct _php_libxml_node_ptr php_libxml_node_ptr;
struct _xmlNode;
typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;
struct _php_libxml_node_ptr {
   xmlNodePtr node ;
   int refcount ;
   void *_private ;
};
extern void __attribute__((__visibility__("default")))  *zend_object_store_get_object(zval const   *object ) ;
extern zend_bool __attribute__((__visibility__("default")))  instanceof_function(zend_class_entry const   *instance_ce ,
                                                                                 zend_class_entry const   *ce ) ;
extern int __attribute__((__visibility__("default")))  zend_lookup_class(char const   *name ,
                                                                         int name_length ,
                                                                         zend_class_entry ***ce ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *dom_node_class_entry ;
extern zend_class_entry *dom_document_class_entry ;
extern int __attribute__((__visibility__("default")))  zend_parse_method_parameters(int num_args ,
                                                                                    zval *this_ptr ,
                                                                                    char const   *type_spec 
                                                                                    , ...) ;
extern FILE *fopen(char const   * __restrict  __filename ,
                   char const   * __restrict  __modes ) ;
void zim_domdocument_registerNodeClass(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) 
{ zval *id ;
  xmlDoc *docp ;
  char *baseclass ;
  char *extendedclass ;
  int baseclass_len ;
  int extendedclass_len ;
  zend_class_entry *basece ;
  zend_class_entry *ce ;
  dom_object *intern ;
  int __attribute__((__visibility__("default")))  tmp ;
  zend_class_entry **pce ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___1 ;
  zend_class_entry **pce___0 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  int tmp___4 ;
  zval *__z ;
  zend_bool __attribute__((__visibility__("default")))  tmp___5 ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3247\n");
  fflush(_coverage_fout);
  }
  baseclass = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "3248\n");
  fflush(_coverage_fout);
  }
  extendedclass = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "3249\n");
  fflush(_coverage_fout);
  }
  baseclass_len = 0;
  {
  fprintf(_coverage_fout, "3250\n");
  fflush(_coverage_fout);
  }
  extendedclass_len = 0;
  {
  fprintf(_coverage_fout, "3251\n");
  fflush(_coverage_fout);
  }
  basece = (zend_class_entry *)((void *)0);
  {
  fprintf(_coverage_fout, "3252\n");
  fflush(_coverage_fout);
  }
  ce = (zend_class_entry *)((void *)0);
  {
  fprintf(_coverage_fout, "3253\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Oss!", & id,
                                     dom_document_class_entry, & baseclass,
                                     & baseclass_len, & extendedclass,
                                     & extendedclass_len);
  {
  fprintf(_coverage_fout, "3254\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "3198\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3199\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3255\n");
  fflush(_coverage_fout);
  }
  if (baseclass_len) {
    {
    fprintf(_coverage_fout, "3203\n");
    fflush(_coverage_fout);
    }
    tmp___0 = zend_lookup_class((char const   *)baseclass, baseclass_len, & pce);
    {
    fprintf(_coverage_fout, "3204\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
      {
      fprintf(_coverage_fout, "3200\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1,
                        "Class %s does not exist", baseclass);
      {
      fprintf(_coverage_fout, "3201\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "3202\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "3205\n");
    fflush(_coverage_fout);
    }
    basece = *pce;
  } else {
    {
    fprintf(_coverage_fout, "3206\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3256\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )basece == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "3207\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1,
                      "Class %s is not derived from DOMNode.", baseclass);
    {
    fprintf(_coverage_fout, "3208\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3212\n");
    fflush(_coverage_fout);
    }
    tmp___1 = instanceof_function((zend_class_entry const   *)basece,
                                  (zend_class_entry const   *)dom_node_class_entry);
    {
    fprintf(_coverage_fout, "3213\n");
    fflush(_coverage_fout);
    }
    if (tmp___1) {
      {
      fprintf(_coverage_fout, "3209\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "3210\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1,
                        "Class %s is not derived from DOMNode.", baseclass);
      {
      fprintf(_coverage_fout, "3211\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "3257\n");
  fflush(_coverage_fout);
  }
  if (extendedclass_len) {
    {
    fprintf(_coverage_fout, "3216\n");
    fflush(_coverage_fout);
    }
    tmp___2 = zend_lookup_class((char const   *)extendedclass,
                                extendedclass_len, & pce___0);
    {
    fprintf(_coverage_fout, "3217\n");
    fflush(_coverage_fout);
    }
    if (tmp___2 == (int __attribute__((__visibility__("default")))  )-1) {
      {
      fprintf(_coverage_fout, "3214\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1,
                        "Class %s does not exist", extendedclass);
    } else {
      {
      fprintf(_coverage_fout, "3215\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "3218\n");
    fflush(_coverage_fout);
    }
    ce = *pce___0;
  } else {
    {
    fprintf(_coverage_fout, "3219\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3258\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )ce == (unsigned int )((void *)0)) {
    goto _L;
  } else {
    {
    fprintf(_coverage_fout, "3242\n");
    fflush(_coverage_fout);
    }
    tmp___5 = instanceof_function((zend_class_entry const   *)ce,
                                  (zend_class_entry const   *)basece);
    {
    fprintf(_coverage_fout, "3243\n");
    fflush(_coverage_fout);
    }
    if (tmp___5) {
      {
      fprintf(_coverage_fout, "3234\n");
      fflush(_coverage_fout);
      }
      _L: /* CIL Label */ 
      tmp___3 = zend_object_store_get_object((zval const   *)id);
      {
      fprintf(_coverage_fout, "3235\n");
      fflush(_coverage_fout);
      }
      intern = (dom_object *)tmp___3;
      {
      fprintf(_coverage_fout, "3236\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
        {
        fprintf(_coverage_fout, "3220\n");
        fflush(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Couldn\'t fetch %s", (intern->std.ce)->name);
        {
        fprintf(_coverage_fout, "3221\n");
        fflush(_coverage_fout);
        }
        return_value->type = (unsigned char)0;
        {
        fprintf(_coverage_fout, "3222\n");
        fflush(_coverage_fout);
        }
        return;
      } else {
        {
        fprintf(_coverage_fout, "3227\n");
        fflush(_coverage_fout);
        }
        docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
        {
        fprintf(_coverage_fout, "3228\n");
        fflush(_coverage_fout);
        }
        if (docp) {
          {
          fprintf(_coverage_fout, "3223\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "3224\n");
          fflush(_coverage_fout);
          }
          php_error_docref0((char const   *)((void *)0), 1 << 1L,
                            "Couldn\'t fetch %s", (intern->std.ce)->name);
          {
          fprintf(_coverage_fout, "3225\n");
          fflush(_coverage_fout);
          }
          return_value->type = (unsigned char)0;
          {
          fprintf(_coverage_fout, "3226\n");
          fflush(_coverage_fout);
          }
          return;
        }
      }
      {
      fprintf(_coverage_fout, "3237\n");
      fflush(_coverage_fout);
      }
      tmp___4 = dom_set_doc_classmap(intern->document, basece, ce);
      {
      fprintf(_coverage_fout, "3238\n");
      fflush(_coverage_fout);
      }
      if (tmp___4 == -1) {
        {
        fprintf(_coverage_fout, "3229\n");
        fflush(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1,
                          "Class %s could not be registered.", extendedclass);
      } else {
        {
        fprintf(_coverage_fout, "3230\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "3239\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3231\n");
        fflush(_coverage_fout);
        }
        __z = return_value;
        {
        fprintf(_coverage_fout, "3232\n");
        fflush(_coverage_fout);
        }
        __z->value.lval = 1L;
        {
        fprintf(_coverage_fout, "3233\n");
        fflush(_coverage_fout);
        }
        __z->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "3240\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "3241\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1,
                        "Class %s is not derived from %s.", extendedclass,
                        baseclass);
    }
  }
  {
  fprintf(_coverage_fout, "3259\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "3244\n");
    fflush(_coverage_fout);
    }
    __z___0 = return_value;
    {
    fprintf(_coverage_fout, "3245\n");
    fflush(_coverage_fout);
    }
    __z___0->value.lval = 0L;
    {
    fprintf(_coverage_fout, "3246\n");
    fflush(_coverage_fout);
    }
    __z___0->type = (unsigned char)3;
    break;
  }
  {
  fprintf(_coverage_fout, "3260\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zim_domdocument_registerNodeClass(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
typedef unsigned char xmlChar;
extern void (*xmlFree)(void *mem ) ;
extern char __attribute__((__visibility__("default")))  *_estrndup(char const   *s ,
                                                                   unsigned int length )  __attribute__((__malloc__)) ;
typedef xmlDoc *xmlDocPtr;
extern void htmlDocDumpMemoryFormat(xmlDocPtr cur , xmlChar **mem , int *size ,
                                    int format ) ;
struct _xmlBuffer;
typedef struct _xmlBuffer xmlBuffer;
typedef xmlBuffer *xmlBufferPtr;
extern void xmlBufferFree(xmlBufferPtr buf ) ;
typedef unsigned int size_t;
extern  __attribute__((__nothrow__)) size_t strlen(char const   *__s )  __attribute__((__pure__,
__nonnull__(1))) ;
extern xmlChar const   *xmlBufferContent(xmlBufferPtr buf ) ;
struct _xmlOutputBuffer;
typedef struct _xmlOutputBuffer xmlOutputBuffer;
typedef xmlOutputBuffer *xmlOutputBufferPtr;
extern void htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf , xmlDocPtr doc ,
                                     xmlNodePtr cur , char const   *encoding ,
                                     int format ) ;
extern xmlBufferPtr xmlBufferCreate(void) ;
extern void php_dom_throw_error(int error_code , int strict_error ) ;
extern int dom_get_strict_error(php_libxml_ref_obj *document ) ;
struct _xmlNs;
typedef struct _xmlNs xmlNs;
struct _xmlAttr;
enum __anonenum_xmlElementType_81 {
    XML_ELEMENT_NODE = 1,
    XML_ATTRIBUTE_NODE = 2,
    XML_TEXT_NODE = 3,
    XML_CDATA_SECTION_NODE = 4,
    XML_ENTITY_REF_NODE = 5,
    XML_ENTITY_NODE = 6,
    XML_PI_NODE = 7,
    XML_COMMENT_NODE = 8,
    XML_DOCUMENT_NODE = 9,
    XML_DOCUMENT_TYPE_NODE = 10,
    XML_DOCUMENT_FRAG_NODE = 11,
    XML_NOTATION_NODE = 12,
    XML_HTML_DOCUMENT_NODE = 13,
    XML_DTD_NODE = 14,
    XML_ELEMENT_DECL = 15,
    XML_ATTRIBUTE_DECL = 16,
    XML_ENTITY_DECL = 17,
    XML_NAMESPACE_DECL = 18,
    XML_XINCLUDE_START = 19,
    XML_XINCLUDE_END = 20,
    XML_DOCB_DOCUMENT_NODE = 21
} ;
typedef enum __anonenum_xmlElementType_81 xmlElementType;
struct _xmlNode {
   void *_private ;
   xmlElementType type ;
   xmlChar const   *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlNode *parent ;
   struct _xmlNode *next ;
   struct _xmlNode *prev ;
   struct _xmlDoc *doc ;
   xmlNs *ns ;
   xmlChar *content ;
   struct _xmlAttr *properties ;
   xmlNs *nsDef ;
   void *psvi ;
   unsigned short line ;
   unsigned short extra ;
};
struct _libxml_doc_props;
typedef struct _libxml_doc_props libxml_doc_props;
typedef libxml_doc_props *dom_doc_propsptr;
struct _libxml_doc_props {
   int formatoutput ;
   int validateonparse ;
   int resolveexternals ;
   int preservewhitespace ;
   int substituteentities ;
   int stricterror ;
   int recover ;
   HashTable *classmap ;
};
extern dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document ) ;
void zif_dom_document_save_html(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) 
{ zval *id ;
  zval *nodep ;
  xmlDoc *docp ;
  xmlNode *node ;
  xmlBufferPtr buf ;
  dom_object *intern ;
  dom_object *nodeobj ;
  xmlChar *mem ;
  int size ;
  int format ;
  dom_doc_propsptr doc_props ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  int tmp___2 ;
  zval *__z ;
  zval *__z___0 ;
  xmlChar const   *tmp___3 ;
  zval *__z___1 ;
  char const   *__s ;
  zval *__z___2 ;
  size_t tmp___4 ;
  char __attribute__((__visibility__("default")))  *tmp___5 ;
  zval *__z___3 ;
  char const   *__s___0 ;
  int __l ;
  zval *__z___4 ;
  char __attribute__((__visibility__("default")))  *tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3187\n");
  fflush(_coverage_fout);
  }
  nodep = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "3188\n");
  fflush(_coverage_fout);
  }
  mem = (xmlChar *)((void *)0);
  {
  fprintf(_coverage_fout, "3189\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O|O!", & id,
                                     dom_document_class_entry, & nodep,
                                     dom_node_class_entry);
  {
  fprintf(_coverage_fout, "3190\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "3112\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3113\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3191\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "3192\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "3193\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "3114\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "3115\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "3116\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3121\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "3122\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "3117\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "3118\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "3119\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "3120\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "3194\n");
  fflush(_coverage_fout);
  }
  doc_props = dom_get_doc_props(intern->document);
  {
  fprintf(_coverage_fout, "3195\n");
  fflush(_coverage_fout);
  }
  format = doc_props->formatoutput;
  {
  fprintf(_coverage_fout, "3196\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodep != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "3159\n");
    fflush(_coverage_fout);
    }
    tmp___1 = zend_object_store_get_object((zval const   *)nodep);
    {
    fprintf(_coverage_fout, "3160\n");
    fflush(_coverage_fout);
    }
    nodeobj = (dom_object *)tmp___1;
    {
    fprintf(_coverage_fout, "3161\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )nodeobj->ptr == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "3123\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (nodeobj->std.ce)->name);
      {
      fprintf(_coverage_fout, "3124\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "3125\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "3130\n");
      fflush(_coverage_fout);
      }
      node = ((php_libxml_node_ptr *)nodeobj->ptr)->node;
      {
      fprintf(_coverage_fout, "3131\n");
      fflush(_coverage_fout);
      }
      if (node) {
        {
        fprintf(_coverage_fout, "3126\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "3127\n");
        fflush(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Couldn\'t fetch %s", (nodeobj->std.ce)->name);
        {
        fprintf(_coverage_fout, "3128\n");
        fflush(_coverage_fout);
        }
        return_value->type = (unsigned char)0;
        {
        fprintf(_coverage_fout, "3129\n");
        fflush(_coverage_fout);
        }
        return;
      }
    }
    {
    fprintf(_coverage_fout, "3162\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )node->doc != (unsigned int )docp) {
      {
      fprintf(_coverage_fout, "3135\n");
      fflush(_coverage_fout);
      }
      tmp___2 = dom_get_strict_error(intern->document);
      {
      fprintf(_coverage_fout, "3136\n");
      fflush(_coverage_fout);
      }
      php_dom_throw_error(4, tmp___2);
      {
      fprintf(_coverage_fout, "3137\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3132\n");
        fflush(_coverage_fout);
        }
        __z = return_value;
        {
        fprintf(_coverage_fout, "3133\n");
        fflush(_coverage_fout);
        }
        __z->value.lval = 0L;
        {
        fprintf(_coverage_fout, "3134\n");
        fflush(_coverage_fout);
        }
        __z->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "3138\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "3139\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "3163\n");
    fflush(_coverage_fout);
    }
    buf = xmlBufferCreate();
    {
    fprintf(_coverage_fout, "3164\n");
    fflush(_coverage_fout);
    }
    if (! buf) {
      {
      fprintf(_coverage_fout, "3143\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Could not fetch buffer");
      {
      fprintf(_coverage_fout, "3144\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3140\n");
        fflush(_coverage_fout);
        }
        __z___0 = return_value;
        {
        fprintf(_coverage_fout, "3141\n");
        fflush(_coverage_fout);
        }
        __z___0->value.lval = 0L;
        {
        fprintf(_coverage_fout, "3142\n");
        fflush(_coverage_fout);
        }
        __z___0->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "3145\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "3146\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "3165\n");
    fflush(_coverage_fout);
    }
    htmlNodeDumpFormatOutput((xmlOutputBuffer *)buf, docp, node,
                             (char const   *)0, format);
    {
    fprintf(_coverage_fout, "3166\n");
    fflush(_coverage_fout);
    }
    tmp___3 = xmlBufferContent(buf);
    {
    fprintf(_coverage_fout, "3167\n");
    fflush(_coverage_fout);
    }
    mem = (xmlChar *)tmp___3;
    {
    fprintf(_coverage_fout, "3168\n");
    fflush(_coverage_fout);
    }
    if (! mem) {
      {
      fprintf(_coverage_fout, "3150\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3147\n");
        fflush(_coverage_fout);
        }
        __z___1 = return_value;
        {
        fprintf(_coverage_fout, "3148\n");
        fflush(_coverage_fout);
        }
        __z___1->value.lval = 0L;
        {
        fprintf(_coverage_fout, "3149\n");
        fflush(_coverage_fout);
        }
        __z___1->type = (unsigned char)3;
        break;
      }
    } else {
      {
      fprintf(_coverage_fout, "3158\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3151\n");
        fflush(_coverage_fout);
        }
        __s = (char const   *)mem;
        {
        fprintf(_coverage_fout, "3152\n");
        fflush(_coverage_fout);
        }
        __z___2 = return_value;
        {
        fprintf(_coverage_fout, "3153\n");
        fflush(_coverage_fout);
        }
        tmp___4 = strlen(__s);
        {
        fprintf(_coverage_fout, "3154\n");
        fflush(_coverage_fout);
        }
        __z___2->value.str.len = (int )tmp___4;
        {
        fprintf(_coverage_fout, "3155\n");
        fflush(_coverage_fout);
        }
        tmp___5 = _estrndup(__s, (unsigned int )__z___2->value.str.len);
        {
        fprintf(_coverage_fout, "3156\n");
        fflush(_coverage_fout);
        }
        __z___2->value.str.val = (char *)tmp___5;
        {
        fprintf(_coverage_fout, "3157\n");
        fflush(_coverage_fout);
        }
        __z___2->type = (unsigned char)6;
        break;
      }
    }
    {
    fprintf(_coverage_fout, "3169\n");
    fflush(_coverage_fout);
    }
    xmlBufferFree(buf);
  } else {
    {
    fprintf(_coverage_fout, "3184\n");
    fflush(_coverage_fout);
    }
    htmlDocDumpMemoryFormat(docp, & mem, & size, format);
    {
    fprintf(_coverage_fout, "3185\n");
    fflush(_coverage_fout);
    }
    if (! size) {
      {
      fprintf(_coverage_fout, "3173\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3170\n");
        fflush(_coverage_fout);
        }
        __z___3 = return_value;
        {
        fprintf(_coverage_fout, "3171\n");
        fflush(_coverage_fout);
        }
        __z___3->value.lval = 0L;
        {
        fprintf(_coverage_fout, "3172\n");
        fflush(_coverage_fout);
        }
        __z___3->type = (unsigned char)3;
        break;
      }
    } else {
      {
      fprintf(_coverage_fout, "3181\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3174\n");
        fflush(_coverage_fout);
        }
        __s___0 = (char const   *)mem;
        {
        fprintf(_coverage_fout, "3175\n");
        fflush(_coverage_fout);
        }
        __l = size;
        {
        fprintf(_coverage_fout, "3176\n");
        fflush(_coverage_fout);
        }
        __z___4 = return_value;
        {
        fprintf(_coverage_fout, "3177\n");
        fflush(_coverage_fout);
        }
        __z___4->value.str.len = __l;
        {
        fprintf(_coverage_fout, "3178\n");
        fflush(_coverage_fout);
        }
        tmp___6 = _estrndup(__s___0, (unsigned int )__l);
        {
        fprintf(_coverage_fout, "3179\n");
        fflush(_coverage_fout);
        }
        __z___4->value.str.val = (char *)tmp___6;
        {
        fprintf(_coverage_fout, "3180\n");
        fflush(_coverage_fout);
        }
        __z___4->type = (unsigned char)6;
        break;
      }
    }
    {
    fprintf(_coverage_fout, "3186\n");
    fflush(_coverage_fout);
    }
    if (mem) {
      {
      fprintf(_coverage_fout, "3182\n");
      fflush(_coverage_fout);
      }
      (*xmlFree)((void *)mem);
    } else {
      {
      fprintf(_coverage_fout, "3183\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "3197\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_save_html(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
extern int htmlSaveFileFormat(char const   *filename , xmlDocPtr cur ,
                              char const   *encoding , int format ) ;
typedef xmlDocPtr htmlDocPtr;
extern xmlChar const   *htmlGetMetaEncoding(htmlDocPtr doc ) ;
void zif_dom_document_save_html_file(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) 
{ zval *id ;
  xmlDoc *docp ;
  int file_len ;
  int bytes ;
  int format ;
  dom_object *intern ;
  dom_doc_propsptr doc_props ;
  char *file ;
  char const   *encoding ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  xmlChar const   *tmp___1 ;
  zval *__z___0 ;
  zval *__z___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3096\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & file,
                                     & file_len);
  {
  fprintf(_coverage_fout, "3097\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "3072\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3073\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3098\n");
  fflush(_coverage_fout);
  }
  if (file_len == 0) {
    {
    fprintf(_coverage_fout, "3077\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid Filename");
    {
    fprintf(_coverage_fout, "3078\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "3074\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "3075\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "3076\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "3079\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3080\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3099\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "3100\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "3101\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "3081\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "3082\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "3083\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3088\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "3089\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "3084\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "3085\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "3086\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "3087\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "3102\n");
  fflush(_coverage_fout);
  }
  tmp___1 = htmlGetMetaEncoding(docp);
  {
  fprintf(_coverage_fout, "3103\n");
  fflush(_coverage_fout);
  }
  encoding = (char const   *)tmp___1;
  {
  fprintf(_coverage_fout, "3104\n");
  fflush(_coverage_fout);
  }
  doc_props = dom_get_doc_props(intern->document);
  {
  fprintf(_coverage_fout, "3105\n");
  fflush(_coverage_fout);
  }
  format = doc_props->formatoutput;
  {
  fprintf(_coverage_fout, "3106\n");
  fflush(_coverage_fout);
  }
  bytes = htmlSaveFileFormat((char const   *)file, docp, encoding, format);
  {
  fprintf(_coverage_fout, "3107\n");
  fflush(_coverage_fout);
  }
  if (bytes == -1) {
    {
    fprintf(_coverage_fout, "3093\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "3090\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "3091\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "3092\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "3094\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3095\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3108\n");
  fflush(_coverage_fout);
  }
  __z___1 = return_value;
  {
  fprintf(_coverage_fout, "3109\n");
  fflush(_coverage_fout);
  }
  __z___1->value.lval = (long )bytes;
  {
  fprintf(_coverage_fout, "3110\n");
  fflush(_coverage_fout);
  }
  __z___1->type = (unsigned char)1;
  {
  fprintf(_coverage_fout, "3111\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_save_html_file(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
static void dom_load_html(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used , int mode ) ;
void zim_domdocument_loadHTML(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3070\n");
  fflush(_coverage_fout);
  }
  dom_load_html(ht, return_value, return_value_ptr, this_ptr, return_value_used,
                0);
  {
  fprintf(_coverage_fout, "3071\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zim_domdocument_loadHTML(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
void zim_domdocument_loadHTMLFile(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3068\n");
  fflush(_coverage_fout);
  }
  dom_load_html(ht, return_value, return_value_ptr, this_ptr, return_value_used,
                1);
  {
  fprintf(_coverage_fout, "3069\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zim_domdocument_loadHTMLFile(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern zval __attribute__((__visibility__("default")))  *php_dom_create_object(xmlNodePtr obj ,
                                                                               int *found ,
                                                                               zval *in ,
                                                                               zval *return_value ,
                                                                               dom_object *domobj ) ;
struct _php_libxml_node_object;
typedef struct _php_libxml_node_object php_libxml_node_object;
extern int __attribute__((__visibility__("default")))  php_libxml_increment_node_ptr(php_libxml_node_object *object ,
                                                                                     xmlNodePtr node ,
                                                                                     void *private_data ) ;
struct _php_libxml_ref_obj {
   void *ptr ;
   int refcount ;
   libxml_doc_props *doc_props ;
};
extern int __attribute__((__visibility__("default")))  php_libxml_increment_doc_ref(php_libxml_node_object *object ,
                                                                                    xmlDocPtr docp ) ;
struct _xmlDict;
struct _xmlDtd;
struct _xmlDoc {
   void *_private ;
   xmlElementType type ;
   char *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlNode *parent ;
   struct _xmlNode *next ;
   struct _xmlNode *prev ;
   struct _xmlDoc *doc ;
   int compression ;
   int standalone ;
   struct _xmlDtd *intSubset ;
   struct _xmlDtd *extSubset ;
   struct _xmlNs *oldNs ;
   xmlChar const   *version ;
   xmlChar const   *encoding ;
   void *ids ;
   void *refs ;
   xmlChar const   *URL ;
   int charset ;
   struct _xmlDict *dict ;
   void *psvi ;
   int parseFlags ;
   int properties ;
};
extern int __attribute__((__visibility__("default")))  php_libxml_decrement_doc_ref(php_libxml_node_object *object ) ;
extern int __attribute__((__visibility__("default")))  php_libxml_decrement_node_ptr(php_libxml_node_object *object ) ;
extern xmlNodePtr __attribute__((__visibility__("default")))  dom_object_get_node(dom_object *obj ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_get_class_entry(zval const   *zobject ) ;
struct _xmlParserCtxt;
typedef struct _xmlParserCtxt xmlParserCtxt;
typedef xmlParserCtxt *xmlParserCtxtPtr;
typedef xmlParserCtxtPtr htmlParserCtxtPtr;
extern void htmlFreeParserCtxt(htmlParserCtxtPtr ctxt ) ;
struct _xmlParserNodeInfo;
typedef struct _xmlParserNodeInfo xmlParserNodeInfo;
enum __anonenum_xmlParserMode_94 {
    XML_PARSE_UNKNOWN = 0,
    XML_PARSE_DOM = 1,
    XML_PARSE_SAX = 2,
    XML_PARSE_PUSH_DOM = 3,
    XML_PARSE_PUSH_SAX = 4,
    XML_PARSE_READER = 5
} ;
typedef enum __anonenum_xmlParserMode_94 xmlParserMode;
enum __anonenum_xmlErrorLevel_89 {
    XML_ERR_NONE = 0,
    XML_ERR_WARNING = 1,
    XML_ERR_ERROR = 2,
    XML_ERR_FATAL = 3
} ;
typedef enum __anonenum_xmlErrorLevel_89 xmlErrorLevel;
struct _xmlError {
   int domain ;
   int code ;
   char *message ;
   xmlErrorLevel level ;
   char *file ;
   int line ;
   char *str1 ;
   char *str2 ;
   char *str3 ;
   int int1 ;
   int int2 ;
   void *ctxt ;
   void *node ;
};
typedef struct _xmlError xmlError;
typedef struct _xmlAttr xmlAttr;
typedef xmlAttr *xmlAttrPtr;
struct _xmlHashTable;
typedef struct _xmlHashTable xmlHashTable;
typedef xmlHashTable *xmlHashTablePtr;
typedef struct _xmlDict xmlDict;
typedef xmlDict *xmlDictPtr;
struct _xmlParserInput;
typedef struct _xmlParserInput xmlParserInput;
typedef xmlParserInput *xmlParserInputPtr;
enum __anonenum_xmlParserInputState_93 {
    XML_PARSER_EOF = -1,
    XML_PARSER_START = 0,
    XML_PARSER_MISC = 1,
    XML_PARSER_PI = 2,
    XML_PARSER_DTD = 3,
    XML_PARSER_PROLOG = 4,
    XML_PARSER_COMMENT = 5,
    XML_PARSER_START_TAG = 6,
    XML_PARSER_CONTENT = 7,
    XML_PARSER_CDATA_SECTION = 8,
    XML_PARSER_END_TAG = 9,
    XML_PARSER_ENTITY_DECL = 10,
    XML_PARSER_ENTITY_VALUE = 11,
    XML_PARSER_ATTRIBUTE_VALUE = 12,
    XML_PARSER_SYSTEM_LITERAL = 13,
    XML_PARSER_EPILOG = 14,
    XML_PARSER_IGNORE = 15,
    XML_PARSER_PUBLIC_LITERAL = 16
} ;
typedef enum __anonenum_xmlParserInputState_93 xmlParserInputState;
struct _xmlAutomataState;
typedef struct _xmlAutomataState xmlAutomataState;
typedef xmlAutomataState *xmlAutomataStatePtr;
struct _xmlAutomata;
typedef struct _xmlAutomata xmlAutomata;
typedef xmlAutomata *xmlAutomataPtr;
struct _xmlValidState;
typedef struct _xmlValidState xmlValidState;
struct _xmlValidCtxt {
   void *userData ;
   void ( /* format attribute */  (*error))(void *ctx , char const   *msg  , ...) ;
   void ( /* format attribute */  (*warning))(void *ctx , char const   *msg 
                                              , ...) ;
   xmlNodePtr node ;
   int nodeNr ;
   int nodeMax ;
   xmlNodePtr *nodeTab ;
   unsigned int finishDtd ;
   xmlDocPtr doc ;
   int valid ;
   xmlValidState *vstate ;
   int vstateNr ;
   int vstateMax ;
   xmlValidState *vstateTab ;
   xmlAutomataPtr am ;
   xmlAutomataStatePtr state ;
};
typedef struct _xmlValidCtxt xmlValidCtxt;
struct _xmlParserNodeInfoSeq {
   unsigned long maximum ;
   unsigned long length ;
   xmlParserNodeInfo *buffer ;
};
typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq;
struct _xmlSAXHandler;
struct _xmlParserCtxt {
   struct _xmlSAXHandler *sax ;
   void *userData ;
   xmlDocPtr myDoc ;
   int wellFormed ;
   int replaceEntities ;
   xmlChar const   *version ;
   xmlChar const   *encoding ;
   int standalone ;
   int html ;
   xmlParserInputPtr input ;
   int inputNr ;
   int inputMax ;
   xmlParserInputPtr *inputTab ;
   xmlNodePtr node ;
   int nodeNr ;
   int nodeMax ;
   xmlNodePtr *nodeTab ;
   int record_info ;
   xmlParserNodeInfoSeq node_seq ;
   int errNo ;
   int hasExternalSubset ;
   int hasPErefs ;
   int external ;
   int valid ;
   int validate ;
   xmlValidCtxt vctxt ;
   xmlParserInputState instate ;
   int token ;
   char *directory ;
   xmlChar const   *name ;
   int nameNr ;
   int nameMax ;
   xmlChar const   **nameTab ;
   long nbChars ;
   long checkIndex ;
   int keepBlanks ;
   int disableSAX ;
   int inSubset ;
   xmlChar const   *intSubName ;
   xmlChar *extSubURI ;
   xmlChar *extSubSystem ;
   int *space ;
   int spaceNr ;
   int spaceMax ;
   int *spaceTab ;
   int depth ;
   xmlParserInputPtr entity ;
   int charset ;
   int nodelen ;
   int nodemem ;
   int pedantic ;
   void *_private ;
   int loadsubset ;
   int linenumbers ;
   void *catalogs ;
   int recovery ;
   int progressive ;
   xmlDictPtr dict ;
   xmlChar const   **atts ;
   int maxatts ;
   int docdict ;
   xmlChar const   *str_xml ;
   xmlChar const   *str_xmlns ;
   xmlChar const   *str_xml_ns ;
   int sax2 ;
   int nsNr ;
   int nsMax ;
   xmlChar const   **nsTab ;
   int *attallocs ;
   void **pushTab ;
   xmlHashTablePtr attsDefault ;
   xmlHashTablePtr attsSpecial ;
   int nsWellFormed ;
   int options ;
   int dictNames ;
   int freeElemsNr ;
   xmlNodePtr freeElems ;
   int freeAttrsNr ;
   xmlAttrPtr freeAttrs ;
   xmlError lastError ;
   xmlParserMode parseMode ;
   unsigned long nbentities ;
   unsigned long sizeentities ;
   xmlParserNodeInfo *nodeInfo ;
   int nodeInfoNr ;
   int nodeInfoMax ;
   xmlParserNodeInfo *nodeInfoTab ;
};
extern int htmlParseDocument(htmlParserCtxtPtr ctxt ) ;
extern void __attribute__((__visibility__("default")))  php_libxml_ctx_warning(void *ctx ,
                                                                               char const   *msg 
                                                                               , ...) ;
struct _xmlError;
typedef xmlError *xmlErrorPtr;
struct _xmlEntity;
typedef struct _xmlEntity xmlEntity;
typedef xmlEntity *xmlEntityPtr;
struct _xmlSAXLocator;
typedef struct _xmlSAXLocator xmlSAXLocator;
typedef xmlSAXLocator *xmlSAXLocatorPtr;
struct _xmlElementContent;
typedef struct _xmlElementContent xmlElementContent;
typedef xmlElementContent *xmlElementContentPtr;
struct _xmlEnumeration;
typedef struct _xmlEnumeration xmlEnumeration;
typedef xmlEnumeration *xmlEnumerationPtr;
struct _xmlSAXHandler {
   void (*internalSubset)(void *ctx , xmlChar const   *name ,
                          xmlChar const   *ExternalID ,
                          xmlChar const   *SystemID ) ;
   int (*isStandalone)(void *ctx ) ;
   int (*hasInternalSubset)(void *ctx ) ;
   int (*hasExternalSubset)(void *ctx ) ;
   xmlParserInputPtr (*resolveEntity)(void *ctx , xmlChar const   *publicId ,
                                      xmlChar const   *systemId ) ;
   xmlEntityPtr (*getEntity)(void *ctx , xmlChar const   *name ) ;
   void (*entityDecl)(void *ctx , xmlChar const   *name , int type ,
                      xmlChar const   *publicId , xmlChar const   *systemId ,
                      xmlChar *content ) ;
   void (*notationDecl)(void *ctx , xmlChar const   *name ,
                        xmlChar const   *publicId , xmlChar const   *systemId ) ;
   void (*attributeDecl)(void *ctx , xmlChar const   *elem ,
                         xmlChar const   *fullname , int type , int def ,
                         xmlChar const   *defaultValue , xmlEnumerationPtr tree ) ;
   void (*elementDecl)(void *ctx , xmlChar const   *name , int type ,
                       xmlElementContentPtr content ) ;
   void (*unparsedEntityDecl)(void *ctx , xmlChar const   *name ,
                              xmlChar const   *publicId ,
                              xmlChar const   *systemId ,
                              xmlChar const   *notationName ) ;
   void (*setDocumentLocator)(void *ctx , xmlSAXLocatorPtr loc ) ;
   void (*startDocument)(void *ctx ) ;
   void (*endDocument)(void *ctx ) ;
   void (*startElement)(void *ctx , xmlChar const   *name ,
                        xmlChar const   **atts ) ;
   void (*endElement)(void *ctx , xmlChar const   *name ) ;
   void (*reference)(void *ctx , xmlChar const   *name ) ;
   void (*characters)(void *ctx , xmlChar const   *ch , int len ) ;
   void (*ignorableWhitespace)(void *ctx , xmlChar const   *ch , int len ) ;
   void (*processingInstruction)(void *ctx , xmlChar const   *target ,
                                 xmlChar const   *data ) ;
   void (*comment)(void *ctx , xmlChar const   *value ) ;
   void ( /* format attribute */  (*warning))(void *ctx , char const   *msg 
                                              , ...) ;
   void ( /* format attribute */  (*error))(void *ctx , char const   *msg  , ...) ;
   void ( /* format attribute */  (*fatalError))(void *ctx , char const   *msg 
                                                 , ...) ;
   xmlEntityPtr (*getParameterEntity)(void *ctx , xmlChar const   *name ) ;
   void (*cdataBlock)(void *ctx , xmlChar const   *value , int len ) ;
   void (*externalSubset)(void *ctx , xmlChar const   *name ,
                          xmlChar const   *ExternalID ,
                          xmlChar const   *SystemID ) ;
   unsigned int initialized ;
   void *_private ;
   void (*startElementNs)(void *ctx , xmlChar const   *localname ,
                          xmlChar const   *prefix , xmlChar const   *URI ,
                          int nb_namespaces , xmlChar const   **namespaces ,
                          int nb_attributes , int nb_defaulted ,
                          xmlChar const   **attributes ) ;
   void (*endElementNs)(void *ctx , xmlChar const   *localname ,
                        xmlChar const   *prefix , xmlChar const   *URI ) ;
   void (*serror)(void *userData , xmlErrorPtr error ) ;
};
extern void __attribute__((__visibility__("default")))  php_libxml_ctx_error(void *ctx ,
                                                                             char const   *msg 
                                                                             , ...) ;
extern htmlParserCtxtPtr htmlCreateMemoryParserCtxt(char const   *buffer ,
                                                    int size ) ;
extern int xmlStrlen(xmlChar const   *str ) ;
extern htmlParserCtxtPtr htmlCreateFileParserCtxt(char const   *filename ,
                                                  char const   *encoding ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_parameters(int num_args ,
                                                                             char const   *type_spec 
                                                                             , ...) ;
static void dom_load_html(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used , int mode ) 
{ zval *id ;
  zval *rv ;
  xmlDoc *docp ;
  xmlDoc *newdoc ;
  dom_object *intern ;
  dom_doc_propsptr doc_prop ;
  char *source ;
  int source_len ;
  int refcount ;
  int ret ;
  htmlParserCtxtPtr ctxt ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  zval *__z___0 ;
  zval *__z___1 ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  zval *__z___2 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;
  zval *__z___3 ;
  zval *__z___4 ;
  zval __attribute__((__visibility__("default")))  *tmp___4 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___5 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3051\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "3052\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)((void *)0);
  {
  fprintf(_coverage_fout, "3053\n");
  fflush(_coverage_fout);
  }
  id = this_ptr;
  {
  fprintf(_coverage_fout, "3054\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s", & source, & source_len);
  {
  fprintf(_coverage_fout, "3055\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2978\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2979\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3056\n");
  fflush(_coverage_fout);
  }
  if (! source_len) {
    {
    fprintf(_coverage_fout, "2983\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Empty string supplied as input");
    {
    fprintf(_coverage_fout, "2984\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2980\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2981\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2982\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2985\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2986\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3057\n");
  fflush(_coverage_fout);
  }
  if (mode == 1) {
    {
    fprintf(_coverage_fout, "2987\n");
    fflush(_coverage_fout);
    }
    ctxt = htmlCreateFileParserCtxt((char const   *)source,
                                    (char const   *)((void *)0));
  } else {
    {
    fprintf(_coverage_fout, "2988\n");
    fflush(_coverage_fout);
    }
    source_len = xmlStrlen((xmlChar const   *)source);
    {
    fprintf(_coverage_fout, "2989\n");
    fflush(_coverage_fout);
    }
    ctxt = htmlCreateMemoryParserCtxt((char const   *)source, source_len);
  }
  {
  fprintf(_coverage_fout, "3058\n");
  fflush(_coverage_fout);
  }
  if (! ctxt) {
    {
    fprintf(_coverage_fout, "2993\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2990\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2991\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2992\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2994\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2995\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3059\n");
  fflush(_coverage_fout);
  }
  ctxt->vctxt.error = (void ( /* format attribute */  (*))(void *ctx ,
                                                           char const   *msg 
                                                           , ...))(& php_libxml_ctx_error);
  {
  fprintf(_coverage_fout, "3060\n");
  fflush(_coverage_fout);
  }
  ctxt->vctxt.warning = (void ( /* format attribute */  (*))(void *ctx ,
                                                             char const   *msg 
                                                             , ...))(& php_libxml_ctx_warning);
  {
  fprintf(_coverage_fout, "3061\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )ctxt->sax != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2996\n");
    fflush(_coverage_fout);
    }
    (ctxt->sax)->error = (void ( /* format attribute */  (*))(void *ctx ,
                                                              char const   *msg 
                                                              , ...))(& php_libxml_ctx_error);
    {
    fprintf(_coverage_fout, "2997\n");
    fflush(_coverage_fout);
    }
    (ctxt->sax)->warning = (void ( /* format attribute */  (*))(void *ctx ,
                                                                char const   *msg 
                                                                , ...))(& php_libxml_ctx_warning);
  } else {
    {
    fprintf(_coverage_fout, "2998\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3062\n");
  fflush(_coverage_fout);
  }
  htmlParseDocument(ctxt);
  {
  fprintf(_coverage_fout, "3063\n");
  fflush(_coverage_fout);
  }
  newdoc = ctxt->myDoc;
  {
  fprintf(_coverage_fout, "3064\n");
  fflush(_coverage_fout);
  }
  htmlFreeParserCtxt(ctxt);
  {
  fprintf(_coverage_fout, "3065\n");
  fflush(_coverage_fout);
  }
  if (! newdoc) {
    {
    fprintf(_coverage_fout, "3002\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2999\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "3000\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "3001\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "3003\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "3004\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "3066\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )id != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "3038\n");
    fflush(_coverage_fout);
    }
    tmp___5 = zend_get_class_entry((zval const   *)id);
    {
    fprintf(_coverage_fout, "3039\n");
    fflush(_coverage_fout);
    }
    tmp___6 = instanceof_function((zend_class_entry const   *)tmp___5,
                                  (zend_class_entry const   *)dom_document_class_entry);
    {
    fprintf(_coverage_fout, "3040\n");
    fflush(_coverage_fout);
    }
    if (tmp___6) {
      {
      fprintf(_coverage_fout, "3032\n");
      fflush(_coverage_fout);
      }
      tmp___0 = zend_object_store_get_object((zval const   *)id);
      {
      fprintf(_coverage_fout, "3033\n");
      fflush(_coverage_fout);
      }
      intern = (dom_object *)tmp___0;
      {
      fprintf(_coverage_fout, "3034\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )intern != (unsigned int )((void *)0)) {
        {
        fprintf(_coverage_fout, "3020\n");
        fflush(_coverage_fout);
        }
        tmp___1 = dom_object_get_node(intern);
        {
        fprintf(_coverage_fout, "3021\n");
        fflush(_coverage_fout);
        }
        docp = (xmlDoc *)tmp___1;
        {
        fprintf(_coverage_fout, "3022\n");
        fflush(_coverage_fout);
        }
        doc_prop = (libxml_doc_props *)((void *)0);
        {
        fprintf(_coverage_fout, "3023\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )docp != (unsigned int )((void *)0)) {
          {
          fprintf(_coverage_fout, "3007\n");
          fflush(_coverage_fout);
          }
          php_libxml_decrement_node_ptr((php_libxml_node_object *)intern);
          {
          fprintf(_coverage_fout, "3008\n");
          fflush(_coverage_fout);
          }
          doc_prop = (intern->document)->doc_props;
          {
          fprintf(_coverage_fout, "3009\n");
          fflush(_coverage_fout);
          }
          (intern->document)->doc_props = (libxml_doc_props *)((void *)0);
          {
          fprintf(_coverage_fout, "3010\n");
          fflush(_coverage_fout);
          }
          tmp___2 = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
          {
          fprintf(_coverage_fout, "3011\n");
          fflush(_coverage_fout);
          }
          refcount = (int )tmp___2;
          {
          fprintf(_coverage_fout, "3012\n");
          fflush(_coverage_fout);
          }
          if (refcount != 0) {
            {
            fprintf(_coverage_fout, "3005\n");
            fflush(_coverage_fout);
            }
            docp->_private = (void *)0;
          } else {
            {
            fprintf(_coverage_fout, "3006\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "3013\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "3024\n");
        fflush(_coverage_fout);
        }
        intern->document = (php_libxml_ref_obj *)((void *)0);
        {
        fprintf(_coverage_fout, "3025\n");
        fflush(_coverage_fout);
        }
        tmp___3 = php_libxml_increment_doc_ref((php_libxml_node_object *)intern,
                                               newdoc);
        {
        fprintf(_coverage_fout, "3026\n");
        fflush(_coverage_fout);
        }
        if (tmp___3 == (int __attribute__((__visibility__("default")))  )-1) {
          {
          fprintf(_coverage_fout, "3017\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "3014\n");
            fflush(_coverage_fout);
            }
            __z___2 = return_value;
            {
            fprintf(_coverage_fout, "3015\n");
            fflush(_coverage_fout);
            }
            __z___2->value.lval = 0L;
            {
            fprintf(_coverage_fout, "3016\n");
            fflush(_coverage_fout);
            }
            __z___2->type = (unsigned char)3;
            break;
          }
          {
          fprintf(_coverage_fout, "3018\n");
          fflush(_coverage_fout);
          }
          return;
        } else {
          {
          fprintf(_coverage_fout, "3019\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "3027\n");
        fflush(_coverage_fout);
        }
        (intern->document)->doc_props = doc_prop;
      } else {
        {
        fprintf(_coverage_fout, "3028\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "3035\n");
      fflush(_coverage_fout);
      }
      php_libxml_increment_node_ptr((php_libxml_node_object *)intern,
                                    (xmlNode *)newdoc, (void *)intern);
      {
      fprintf(_coverage_fout, "3036\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3029\n");
        fflush(_coverage_fout);
        }
        __z___3 = return_value;
        {
        fprintf(_coverage_fout, "3030\n");
        fflush(_coverage_fout);
        }
        __z___3->value.lval = 1L;
        {
        fprintf(_coverage_fout, "3031\n");
        fflush(_coverage_fout);
        }
        __z___3->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "3037\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      goto _L;
    }
  } else {
    {
    fprintf(_coverage_fout, "3048\n");
    fflush(_coverage_fout);
    }
    _L: /* CIL Label */ 
    tmp___4 = php_dom_create_object((xmlNode *)newdoc, & ret, rv, return_value,
                                    (dom_object *)((void *)0));
    {
    fprintf(_coverage_fout, "3049\n");
    fflush(_coverage_fout);
    }
    rv = (zval *)tmp___4;
    {
    fprintf(_coverage_fout, "3050\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )((void *)0) == (unsigned int )rv) {
      {
      fprintf(_coverage_fout, "3044\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Cannot create required DOM object");
      {
      fprintf(_coverage_fout, "3045\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "3041\n");
        fflush(_coverage_fout);
        }
        __z___4 = return_value;
        {
        fprintf(_coverage_fout, "3042\n");
        fflush(_coverage_fout);
        }
        __z___4->value.lval = 0L;
        {
        fprintf(_coverage_fout, "3043\n");
        fflush(_coverage_fout);
        }
        __z___4->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "3046\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "3047\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "3067\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void _dom_document_relaxNG_validate(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used , int type ) ;
void zif_dom_document_relaxNG_validate_xml(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2976\n");
  fflush(_coverage_fout);
  }
  _dom_document_relaxNG_validate(ht, return_value, return_value_ptr, this_ptr,
                                 return_value_used, 0);
  {
  fprintf(_coverage_fout, "2977\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_relaxNG_validate_xml(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used ) ;
void zif_dom_document_relaxNG_validate_file(int ht , zval *return_value ,
                                            zval **return_value_ptr ,
                                            zval *this_ptr ,
                                            int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2974\n");
  fflush(_coverage_fout);
  }
  _dom_document_relaxNG_validate(ht, return_value, return_value_ptr, this_ptr,
                                 return_value_used, 1);
  {
  fprintf(_coverage_fout, "2975\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_relaxNG_validate_file(int ht , zval *return_value ,
                                            zval **return_value_ptr ,
                                            zval *this_ptr ,
                                            int return_value_used ) ;
struct _xmlRelaxNGValidCtxt;
typedef struct _xmlRelaxNGValidCtxt xmlRelaxNGValidCtxt;
typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr;
extern void xmlRelaxNGFreeValidCtxt(xmlRelaxNGValidCtxtPtr ctxt ) ;
struct _xmlRelaxNG;
typedef struct _xmlRelaxNG xmlRelaxNG;
typedef xmlRelaxNG *xmlRelaxNGPtr;
extern void xmlRelaxNGFree(xmlRelaxNGPtr schema ) ;
extern int xmlRelaxNGValidateDoc(xmlRelaxNGValidCtxtPtr ctxt , xmlDocPtr doc ) ;
extern void __attribute__((__visibility__("default")))  php_libxml_error_handler(void *ctx ,
                                                                                 char const   *msg 
                                                                                 , ...) ;
extern void xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt ,
                                     void ( /* format attribute */  (*err))(void *ctx ,
                                                                            char const   *msg 
                                                                            , ...) ,
                                     void ( /* format attribute */  (*warn))(void *ctx ,
                                                                             char const   *msg 
                                                                             , ...) ,
                                     void *ctx ) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  zend_error)(int type ,
                                                                                              char const   *format 
                                                                                              , ...) ;
extern xmlRelaxNGValidCtxtPtr xmlRelaxNGNewValidCtxt(xmlRelaxNGPtr schema ) ;
struct _xmlRelaxNGParserCtxt;
typedef struct _xmlRelaxNGParserCtxt xmlRelaxNGParserCtxt;
typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr;
extern void xmlRelaxNGFreeParserCtxt(xmlRelaxNGParserCtxtPtr ctxt ) ;
extern xmlRelaxNGPtr xmlRelaxNGParse(xmlRelaxNGParserCtxtPtr ctxt ) ;
extern void xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt ,
                                      void ( /* format attribute */  (*err))(void *ctx ,
                                                                             char const   *msg 
                                                                             , ...) ,
                                      void ( /* format attribute */  (*warn))(void *ctx ,
                                                                              char const   *msg 
                                                                              , ...) ,
                                      void *ctx ) ;
extern xmlRelaxNGParserCtxtPtr xmlRelaxNGNewMemParserCtxt(char const   *buffer ,
                                                          int size ) ;
extern xmlRelaxNGParserCtxtPtr xmlRelaxNGNewParserCtxt(char const   *URL ) ;
char *_dom_get_valid_file_path(char *source , char *resolved_path ,
                               int resolved_path_len ) ;
static void _dom_document_relaxNG_validate(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used , int type ) 
{ zval *id ;
  xmlDoc *docp ;
  dom_object *intern ;
  char *source ;
  char *valid_file ;
  int source_len ;
  xmlRelaxNGParserCtxtPtr parser ;
  xmlRelaxNGPtr sptr ;
  xmlRelaxNGValidCtxtPtr vptr ;
  int is_valid ;
  char resolved_path[4097] ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp___1 ;
  zval *__z___2 ;
  zval *__z___3 ;
  zval *__z___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2952\n");
  fflush(_coverage_fout);
  }
  source = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2953\n");
  fflush(_coverage_fout);
  }
  valid_file = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2954\n");
  fflush(_coverage_fout);
  }
  source_len = 0;
  {
  fprintf(_coverage_fout, "2955\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & source,
                                     & source_len);
  {
  fprintf(_coverage_fout, "2956\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2896\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2897\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2957\n");
  fflush(_coverage_fout);
  }
  if (source_len == 0) {
    {
    fprintf(_coverage_fout, "2901\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Invalid Schema source");
    {
    fprintf(_coverage_fout, "2902\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2898\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2899\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2900\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2903\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2904\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2958\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2959\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2960\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2905\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2906\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2907\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2912\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2913\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2908\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2909\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2910\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2911\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  switch (type) {
  {
  fprintf(_coverage_fout, "2921\n");
  fflush(_coverage_fout);
  }
  case 1: 
  valid_file = _dom_get_valid_file_path(source, resolved_path, 4096);
  {
  fprintf(_coverage_fout, "2922\n");
  fflush(_coverage_fout);
  }
  if (! valid_file) {
    {
    fprintf(_coverage_fout, "2917\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Invalid RelaxNG file source");
    {
    fprintf(_coverage_fout, "2918\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2914\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2915\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2916\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2919\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2920\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2923\n");
  fflush(_coverage_fout);
  }
  parser = xmlRelaxNGNewParserCtxt((char const   *)valid_file);
  break;
  {
  fprintf(_coverage_fout, "2924\n");
  fflush(_coverage_fout);
  }
  case 0: 
  parser = xmlRelaxNGNewMemParserCtxt((char const   *)source, source_len);
  break;
  {
  fprintf(_coverage_fout, "2925\n");
  fflush(_coverage_fout);
  }
  default: ;
  {
  fprintf(_coverage_fout, "2926\n");
  fflush(_coverage_fout);
  }
  return;
  }
  {
  fprintf(_coverage_fout, "2961\n");
  fflush(_coverage_fout);
  }
  xmlRelaxNGSetParserErrors(parser,
                            (void ( /* format attribute */  (*))(void *ctx ,
                                                                 char const   *msg 
                                                                 , ...))(& php_libxml_error_handler),
                            (void ( /* format attribute */  (*))(void *ctx ,
                                                                 char const   *msg 
                                                                 , ...))(& php_libxml_error_handler),
                            (void *)parser);
  {
  fprintf(_coverage_fout, "2962\n");
  fflush(_coverage_fout);
  }
  sptr = xmlRelaxNGParse(parser);
  {
  fprintf(_coverage_fout, "2963\n");
  fflush(_coverage_fout);
  }
  xmlRelaxNGFreeParserCtxt(parser);
  {
  fprintf(_coverage_fout, "2964\n");
  fflush(_coverage_fout);
  }
  if (! sptr) {
    {
    fprintf(_coverage_fout, "2930\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid RelaxNG");
    {
    fprintf(_coverage_fout, "2931\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2927\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "2928\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2929\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2932\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2933\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2965\n");
  fflush(_coverage_fout);
  }
  tmp___1 = dom_object_get_node(intern);
  {
  fprintf(_coverage_fout, "2966\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp___1;
  {
  fprintf(_coverage_fout, "2967\n");
  fflush(_coverage_fout);
  }
  vptr = xmlRelaxNGNewValidCtxt(sptr);
  {
  fprintf(_coverage_fout, "2968\n");
  fflush(_coverage_fout);
  }
  if (! vptr) {
    {
    fprintf(_coverage_fout, "2937\n");
    fflush(_coverage_fout);
    }
    xmlRelaxNGFree(sptr);
    {
    fprintf(_coverage_fout, "2938\n");
    fflush(_coverage_fout);
    }
    zend_error(1, "Invalid RelaxNG Validation Context");
    {
    fprintf(_coverage_fout, "2939\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2934\n");
      fflush(_coverage_fout);
      }
      __z___2 = return_value;
      {
      fprintf(_coverage_fout, "2935\n");
      fflush(_coverage_fout);
      }
      __z___2->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2936\n");
      fflush(_coverage_fout);
      }
      __z___2->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2940\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2941\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2969\n");
  fflush(_coverage_fout);
  }
  xmlRelaxNGSetValidErrors(vptr,
                           (void ( /* format attribute */  (*))(void *ctx ,
                                                                char const   *msg 
                                                                , ...))(& php_libxml_error_handler),
                           (void ( /* format attribute */  (*))(void *ctx ,
                                                                char const   *msg 
                                                                , ...))(& php_libxml_error_handler),
                           (void *)vptr);
  {
  fprintf(_coverage_fout, "2970\n");
  fflush(_coverage_fout);
  }
  is_valid = xmlRelaxNGValidateDoc(vptr, docp);
  {
  fprintf(_coverage_fout, "2971\n");
  fflush(_coverage_fout);
  }
  xmlRelaxNGFree(sptr);
  {
  fprintf(_coverage_fout, "2972\n");
  fflush(_coverage_fout);
  }
  xmlRelaxNGFreeValidCtxt(vptr);
  {
  fprintf(_coverage_fout, "2973\n");
  fflush(_coverage_fout);
  }
  if (is_valid == 0) {
    {
    fprintf(_coverage_fout, "2945\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2942\n");
      fflush(_coverage_fout);
      }
      __z___3 = return_value;
      {
      fprintf(_coverage_fout, "2943\n");
      fflush(_coverage_fout);
      }
      __z___3->value.lval = 1L;
      {
      fprintf(_coverage_fout, "2944\n");
      fflush(_coverage_fout);
      }
      __z___3->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2946\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2950\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2947\n");
      fflush(_coverage_fout);
      }
      __z___4 = return_value;
      {
      fprintf(_coverage_fout, "2948\n");
      fflush(_coverage_fout);
      }
      __z___4->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2949\n");
      fflush(_coverage_fout);
      }
      __z___4->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2951\n");
    fflush(_coverage_fout);
    }
    return;
  }
}
}
static void _dom_document_schema_validate(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used , int type ) ;
void zif_dom_document_schema_validate_xml(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2894\n");
  fflush(_coverage_fout);
  }
  _dom_document_schema_validate(ht, return_value, return_value_ptr, this_ptr,
                                return_value_used, 0);
  {
  fprintf(_coverage_fout, "2895\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_schema_validate_xml(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
void zif_dom_document_schema_validate_file(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2892\n");
  fflush(_coverage_fout);
  }
  _dom_document_schema_validate(ht, return_value, return_value_ptr, this_ptr,
                                return_value_used, 1);
  {
  fprintf(_coverage_fout, "2893\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_schema_validate_file(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used ) ;
struct _xmlSchemaValidCtxt;
typedef struct _xmlSchemaValidCtxt xmlSchemaValidCtxt;
typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;
extern void xmlSchemaFreeValidCtxt(xmlSchemaValidCtxtPtr ctxt ) ;
struct _xmlSchema;
typedef struct _xmlSchema xmlSchema;
typedef xmlSchema *xmlSchemaPtr;
extern void xmlSchemaFree(xmlSchemaPtr schema ) ;
extern int xmlSchemaValidateDoc(xmlSchemaValidCtxtPtr ctxt , xmlDocPtr instance ) ;
extern void xmlSchemaSetValidErrors(xmlSchemaValidCtxtPtr ctxt ,
                                    void ( /* format attribute */  (*err))(void *ctx ,
                                                                           char const   *msg 
                                                                           , ...) ,
                                    void ( /* format attribute */  (*warn))(void *ctx ,
                                                                            char const   *msg 
                                                                            , ...) ,
                                    void *ctx ) ;
extern xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt(xmlSchemaPtr schema ) ;
struct _xmlSchemaParserCtxt;
typedef struct _xmlSchemaParserCtxt xmlSchemaParserCtxt;
typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;
extern void xmlSchemaFreeParserCtxt(xmlSchemaParserCtxtPtr ctxt ) ;
extern xmlSchemaPtr xmlSchemaParse(xmlSchemaParserCtxtPtr ctxt ) ;
extern void xmlSchemaSetParserErrors(xmlSchemaParserCtxtPtr ctxt ,
                                     void ( /* format attribute */  (*err))(void *ctx ,
                                                                            char const   *msg 
                                                                            , ...) ,
                                     void ( /* format attribute */  (*warn))(void *ctx ,
                                                                             char const   *msg 
                                                                             , ...) ,
                                     void *ctx ) ;
extern xmlSchemaParserCtxtPtr xmlSchemaNewMemParserCtxt(char const   *buffer ,
                                                        int size ) ;
extern xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt(char const   *URL ) ;
static void _dom_document_schema_validate(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used , int type ) 
{ zval *id ;
  xmlDoc *docp ;
  dom_object *intern ;
  char *source ;
  char *valid_file ;
  int source_len ;
  xmlSchemaParserCtxtPtr parser ;
  xmlSchemaPtr sptr ;
  xmlSchemaValidCtxtPtr vptr ;
  int is_valid ;
  char resolved_path[4097] ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp___1 ;
  zval *__z___2 ;
  zval *__z___3 ;
  zval *__z___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2870\n");
  fflush(_coverage_fout);
  }
  source = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2871\n");
  fflush(_coverage_fout);
  }
  valid_file = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2872\n");
  fflush(_coverage_fout);
  }
  source_len = 0;
  {
  fprintf(_coverage_fout, "2873\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & source,
                                     & source_len);
  {
  fprintf(_coverage_fout, "2874\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2814\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2815\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2875\n");
  fflush(_coverage_fout);
  }
  if (source_len == 0) {
    {
    fprintf(_coverage_fout, "2819\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Invalid Schema source");
    {
    fprintf(_coverage_fout, "2820\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2816\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2817\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2818\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2821\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2822\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2876\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2877\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2878\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2823\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2824\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2825\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2830\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2831\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2826\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2827\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2828\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2829\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  switch (type) {
  {
  fprintf(_coverage_fout, "2839\n");
  fflush(_coverage_fout);
  }
  case 1: 
  valid_file = _dom_get_valid_file_path(source, resolved_path, 4096);
  {
  fprintf(_coverage_fout, "2840\n");
  fflush(_coverage_fout);
  }
  if (! valid_file) {
    {
    fprintf(_coverage_fout, "2835\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Invalid Schema file source");
    {
    fprintf(_coverage_fout, "2836\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2832\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2833\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2834\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2837\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2838\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2841\n");
  fflush(_coverage_fout);
  }
  parser = xmlSchemaNewParserCtxt((char const   *)valid_file);
  break;
  {
  fprintf(_coverage_fout, "2842\n");
  fflush(_coverage_fout);
  }
  case 0: 
  parser = xmlSchemaNewMemParserCtxt((char const   *)source, source_len);
  break;
  {
  fprintf(_coverage_fout, "2843\n");
  fflush(_coverage_fout);
  }
  default: ;
  {
  fprintf(_coverage_fout, "2844\n");
  fflush(_coverage_fout);
  }
  return;
  }
  {
  fprintf(_coverage_fout, "2879\n");
  fflush(_coverage_fout);
  }
  xmlSchemaSetParserErrors(parser,
                           (void ( /* format attribute */  (*))(void *ctx ,
                                                                char const   *msg 
                                                                , ...))(& php_libxml_error_handler),
                           (void ( /* format attribute */  (*))(void *ctx ,
                                                                char const   *msg 
                                                                , ...))(& php_libxml_error_handler),
                           (void *)parser);
  {
  fprintf(_coverage_fout, "2880\n");
  fflush(_coverage_fout);
  }
  sptr = xmlSchemaParse(parser);
  {
  fprintf(_coverage_fout, "2881\n");
  fflush(_coverage_fout);
  }
  xmlSchemaFreeParserCtxt(parser);
  {
  fprintf(_coverage_fout, "2882\n");
  fflush(_coverage_fout);
  }
  if (! sptr) {
    {
    fprintf(_coverage_fout, "2848\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid Schema");
    {
    fprintf(_coverage_fout, "2849\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2845\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "2846\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2847\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2850\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2851\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2883\n");
  fflush(_coverage_fout);
  }
  tmp___1 = dom_object_get_node(intern);
  {
  fprintf(_coverage_fout, "2884\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp___1;
  {
  fprintf(_coverage_fout, "2885\n");
  fflush(_coverage_fout);
  }
  vptr = xmlSchemaNewValidCtxt(sptr);
  {
  fprintf(_coverage_fout, "2886\n");
  fflush(_coverage_fout);
  }
  if (! vptr) {
    {
    fprintf(_coverage_fout, "2855\n");
    fflush(_coverage_fout);
    }
    xmlSchemaFree(sptr);
    {
    fprintf(_coverage_fout, "2856\n");
    fflush(_coverage_fout);
    }
    zend_error(1, "Invalid Schema Validation Context");
    {
    fprintf(_coverage_fout, "2857\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2852\n");
      fflush(_coverage_fout);
      }
      __z___2 = return_value;
      {
      fprintf(_coverage_fout, "2853\n");
      fflush(_coverage_fout);
      }
      __z___2->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2854\n");
      fflush(_coverage_fout);
      }
      __z___2->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2858\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2859\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2887\n");
  fflush(_coverage_fout);
  }
  xmlSchemaSetValidErrors(vptr,
                          (void ( /* format attribute */  (*))(void *ctx ,
                                                               char const   *msg 
                                                               , ...))(& php_libxml_error_handler),
                          (void ( /* format attribute */  (*))(void *ctx ,
                                                               char const   *msg 
                                                               , ...))(& php_libxml_error_handler),
                          (void *)vptr);
  {
  fprintf(_coverage_fout, "2888\n");
  fflush(_coverage_fout);
  }
  is_valid = xmlSchemaValidateDoc(vptr, docp);
  {
  fprintf(_coverage_fout, "2889\n");
  fflush(_coverage_fout);
  }
  xmlSchemaFree(sptr);
  {
  fprintf(_coverage_fout, "2890\n");
  fflush(_coverage_fout);
  }
  xmlSchemaFreeValidCtxt(vptr);
  {
  fprintf(_coverage_fout, "2891\n");
  fflush(_coverage_fout);
  }
  if (is_valid == 0) {
    {
    fprintf(_coverage_fout, "2863\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2860\n");
      fflush(_coverage_fout);
      }
      __z___3 = return_value;
      {
      fprintf(_coverage_fout, "2861\n");
      fflush(_coverage_fout);
      }
      __z___3->value.lval = 1L;
      {
      fprintf(_coverage_fout, "2862\n");
      fflush(_coverage_fout);
      }
      __z___3->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2864\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2868\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2865\n");
      fflush(_coverage_fout);
      }
      __z___4 = return_value;
      {
      fprintf(_coverage_fout, "2866\n");
      fflush(_coverage_fout);
      }
      __z___4->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2867\n");
      fflush(_coverage_fout);
      }
      __z___4->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2869\n");
    fflush(_coverage_fout);
    }
    return;
  }
}
}
struct _xmlValidCtxt;
typedef xmlValidCtxt *xmlValidCtxtPtr;
extern void xmlFreeValidCtxt(xmlValidCtxtPtr  ) ;
extern int xmlValidateDocument(xmlValidCtxtPtr ctxt , xmlDocPtr doc ) ;
extern xmlValidCtxtPtr xmlNewValidCtxt(void) ;
void zif_dom_document_validate(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) 
{ zval *id ;
  xmlDoc *docp ;
  dom_object *intern ;
  xmlValidCtxt *cvp ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval *__z___0 ;
  int tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2801\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & id,
                                     dom_document_class_entry);
  {
  fprintf(_coverage_fout, "2802\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2782\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2783\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2803\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2804\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2805\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2784\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2785\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2786\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2791\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2792\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2787\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2788\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2789\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2790\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2806\n");
  fflush(_coverage_fout);
  }
  cvp = xmlNewValidCtxt();
  {
  fprintf(_coverage_fout, "2807\n");
  fflush(_coverage_fout);
  }
  cvp->userData = (void *)0;
  {
  fprintf(_coverage_fout, "2808\n");
  fflush(_coverage_fout);
  }
  cvp->error = (void ( /* format attribute */  (*))(void *ctx ,
                                                    char const   *msg  , ...))(& php_libxml_error_handler);
  {
  fprintf(_coverage_fout, "2809\n");
  fflush(_coverage_fout);
  }
  cvp->warning = (void ( /* format attribute */  (*))(void *ctx ,
                                                      char const   *msg  , ...))(& php_libxml_error_handler);
  {
  fprintf(_coverage_fout, "2810\n");
  fflush(_coverage_fout);
  }
  tmp___1 = xmlValidateDocument(cvp, docp);
  {
  fprintf(_coverage_fout, "2811\n");
  fflush(_coverage_fout);
  }
  if (tmp___1) {
    {
    fprintf(_coverage_fout, "2796\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2793\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2794\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 1L;
      {
      fprintf(_coverage_fout, "2795\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "2800\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2797\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2798\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2799\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "2812\n");
  fflush(_coverage_fout);
  }
  xmlFreeValidCtxt(cvp);
  {
  fprintf(_coverage_fout, "2813\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_validate(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
static void php_dom_remove_xinclude_nodes(xmlNodePtr cur ) ;
extern int xmlXIncludeProcessFlags(xmlDocPtr doc , int flags ) ;
void zif_dom_document_xinclude(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) 
{ zval *id ;
  xmlDoc *docp ;
  xmlNodePtr root ;
  long flags ;
  int err ;
  dom_object *intern ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2770\n");
  fflush(_coverage_fout);
  }
  flags = 0L;
  {
  fprintf(_coverage_fout, "2771\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O|l", & id,
                                     dom_document_class_entry, & flags);
  {
  fprintf(_coverage_fout, "2772\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2745\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2746\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2773\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2774\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2775\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2747\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2748\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2749\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2754\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2755\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2750\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2751\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2752\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2753\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2776\n");
  fflush(_coverage_fout);
  }
  err = xmlXIncludeProcessFlags(docp, (int )flags);
  {
  fprintf(_coverage_fout, "2777\n");
  fflush(_coverage_fout);
  }
  root = docp->children;
  {
  fprintf(_coverage_fout, "2778\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "2759\n");
    fflush(_coverage_fout);
    }
    if (root) {
      {
      fprintf(_coverage_fout, "2758\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )root->type != 1U) {
        {
        fprintf(_coverage_fout, "2757\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )root->type != 19U) {
          {
          fprintf(_coverage_fout, "2756\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "2760\n");
    fflush(_coverage_fout);
    }
    root = root->next;
  }
  {
  fprintf(_coverage_fout, "2779\n");
  fflush(_coverage_fout);
  }
  if (root) {
    {
    fprintf(_coverage_fout, "2761\n");
    fflush(_coverage_fout);
    }
    php_dom_remove_xinclude_nodes(root);
  } else {
    {
    fprintf(_coverage_fout, "2762\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2780\n");
  fflush(_coverage_fout);
  }
  if (err) {
    {
    fprintf(_coverage_fout, "2763\n");
    fflush(_coverage_fout);
    }
    __z = return_value;
    {
    fprintf(_coverage_fout, "2764\n");
    fflush(_coverage_fout);
    }
    __z->value.lval = (long )err;
    {
    fprintf(_coverage_fout, "2765\n");
    fflush(_coverage_fout);
    }
    __z->type = (unsigned char)1;
  } else {
    {
    fprintf(_coverage_fout, "2769\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2766\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2767\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2768\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "2781\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_xinclude(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
static xmlNodePtr php_dom_free_xinclude_node(xmlNodePtr cur ) ;
static void php_dom_remove_xinclude_nodes(xmlNodePtr cur ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2743\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "2741\n");
    fflush(_coverage_fout);
    }
    if (cur) {
      {
      fprintf(_coverage_fout, "2722\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "2742\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )cur->type == 19U) {
      {
      fprintf(_coverage_fout, "2734\n");
      fflush(_coverage_fout);
      }
      cur = php_dom_free_xinclude_node(cur);
      {
      fprintf(_coverage_fout, "2735\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2727\n");
        fflush(_coverage_fout);
        }
        if (cur) {
          {
          fprintf(_coverage_fout, "2724\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )cur->type != 20U) {
            {
            fprintf(_coverage_fout, "2723\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "2728\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )cur->type == 1U) {
          {
          fprintf(_coverage_fout, "2725\n");
          fflush(_coverage_fout);
          }
          php_dom_remove_xinclude_nodes(cur->children);
        } else {
          {
          fprintf(_coverage_fout, "2726\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "2729\n");
        fflush(_coverage_fout);
        }
        cur = cur->next;
      }
      {
      fprintf(_coverage_fout, "2736\n");
      fflush(_coverage_fout);
      }
      if (cur) {
        {
        fprintf(_coverage_fout, "2732\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )cur->type == 20U) {
          {
          fprintf(_coverage_fout, "2730\n");
          fflush(_coverage_fout);
          }
          cur = php_dom_free_xinclude_node(cur);
        } else {
          {
          fprintf(_coverage_fout, "2731\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "2733\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2739\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )cur->type == 1U) {
        {
        fprintf(_coverage_fout, "2737\n");
        fflush(_coverage_fout);
        }
        php_dom_remove_xinclude_nodes(cur->children);
      } else {
        {
        fprintf(_coverage_fout, "2738\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "2740\n");
      fflush(_coverage_fout);
      }
      cur = cur->next;
    }
  }
  {
  fprintf(_coverage_fout, "2744\n");
  fflush(_coverage_fout);
  }
  return;
}
}
extern void __attribute__((__visibility__("default")))  php_libxml_node_free_resource(xmlNodePtr node ) ;
extern void xmlUnlinkNode(xmlNodePtr cur ) ;
static xmlNodePtr php_dom_free_xinclude_node(xmlNodePtr cur ) 
{ xmlNodePtr xincnode ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2717\n");
  fflush(_coverage_fout);
  }
  xincnode = cur;
  {
  fprintf(_coverage_fout, "2718\n");
  fflush(_coverage_fout);
  }
  cur = cur->next;
  {
  fprintf(_coverage_fout, "2719\n");
  fflush(_coverage_fout);
  }
  xmlUnlinkNode(xincnode);
  {
  fprintf(_coverage_fout, "2720\n");
  fflush(_coverage_fout);
  }
  php_libxml_node_free_resource(xincnode);
  {
  fprintf(_coverage_fout, "2721\n");
  fflush(_coverage_fout);
  }
  return (cur);
}
}
extern int *__xmlSaveNoEmptyTags(void) ;
extern void xmlDocDumpFormatMemory(xmlDocPtr cur , xmlChar **mem , int *size ,
                                   int format ) ;
extern int xmlNodeDump(xmlBufferPtr buf , xmlDocPtr doc , xmlNodePtr cur ,
                       int level , int format ) ;
void zif_dom_document_savexml(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ zval *id ;
  zval *nodep ;
  xmlDoc *docp ;
  xmlNode *node ;
  xmlBufferPtr buf ;
  xmlChar *mem ;
  dom_object *intern ;
  dom_object *nodeobj ;
  dom_doc_propsptr doc_props ;
  int size ;
  int format ;
  int saveempty ;
  long options ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  int tmp___2 ;
  zval *__z ;
  zval *__z___0 ;
  int *tmp___3 ;
  int *tmp___4 ;
  int *tmp___5 ;
  xmlChar const   *tmp___6 ;
  zval *__z___1 ;
  char const   *__s ;
  zval *__z___2 ;
  size_t tmp___7 ;
  char __attribute__((__visibility__("default")))  *tmp___8 ;
  int *tmp___9 ;
  int *tmp___10 ;
  int *tmp___11 ;
  zval *__z___3 ;
  char const   *__s___0 ;
  int __l ;
  zval *__z___4 ;
  char __attribute__((__visibility__("default")))  *tmp___12 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2705\n");
  fflush(_coverage_fout);
  }
  nodep = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "2706\n");
  fflush(_coverage_fout);
  }
  saveempty = 0;
  {
  fprintf(_coverage_fout, "2707\n");
  fflush(_coverage_fout);
  }
  options = 0L;
  {
  fprintf(_coverage_fout, "2708\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O|O!l", & id,
                                     dom_document_class_entry, & nodep,
                                     dom_node_class_entry, & options);
  {
  fprintf(_coverage_fout, "2709\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2607\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2608\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2710\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2711\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2712\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2609\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2610\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2611\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2616\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2617\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2612\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2613\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2614\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2615\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2713\n");
  fflush(_coverage_fout);
  }
  doc_props = dom_get_doc_props(intern->document);
  {
  fprintf(_coverage_fout, "2714\n");
  fflush(_coverage_fout);
  }
  format = doc_props->formatoutput;
  {
  fprintf(_coverage_fout, "2715\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodep != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2664\n");
    fflush(_coverage_fout);
    }
    tmp___1 = zend_object_store_get_object((zval const   *)nodep);
    {
    fprintf(_coverage_fout, "2665\n");
    fflush(_coverage_fout);
    }
    nodeobj = (dom_object *)tmp___1;
    {
    fprintf(_coverage_fout, "2666\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )nodeobj->ptr == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "2618\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (nodeobj->std.ce)->name);
      {
      fprintf(_coverage_fout, "2619\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2620\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2625\n");
      fflush(_coverage_fout);
      }
      node = ((php_libxml_node_ptr *)nodeobj->ptr)->node;
      {
      fprintf(_coverage_fout, "2626\n");
      fflush(_coverage_fout);
      }
      if (node) {
        {
        fprintf(_coverage_fout, "2621\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "2622\n");
        fflush(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Couldn\'t fetch %s", (nodeobj->std.ce)->name);
        {
        fprintf(_coverage_fout, "2623\n");
        fflush(_coverage_fout);
        }
        return_value->type = (unsigned char)0;
        {
        fprintf(_coverage_fout, "2624\n");
        fflush(_coverage_fout);
        }
        return;
      }
    }
    {
    fprintf(_coverage_fout, "2667\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )node->doc != (unsigned int )docp) {
      {
      fprintf(_coverage_fout, "2630\n");
      fflush(_coverage_fout);
      }
      tmp___2 = dom_get_strict_error(intern->document);
      {
      fprintf(_coverage_fout, "2631\n");
      fflush(_coverage_fout);
      }
      php_dom_throw_error(4, tmp___2);
      {
      fprintf(_coverage_fout, "2632\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2627\n");
        fflush(_coverage_fout);
        }
        __z = return_value;
        {
        fprintf(_coverage_fout, "2628\n");
        fflush(_coverage_fout);
        }
        __z->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2629\n");
        fflush(_coverage_fout);
        }
        __z->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2633\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2634\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2668\n");
    fflush(_coverage_fout);
    }
    buf = xmlBufferCreate();
    {
    fprintf(_coverage_fout, "2669\n");
    fflush(_coverage_fout);
    }
    if (! buf) {
      {
      fprintf(_coverage_fout, "2638\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Could not fetch buffer");
      {
      fprintf(_coverage_fout, "2639\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2635\n");
        fflush(_coverage_fout);
        }
        __z___0 = return_value;
        {
        fprintf(_coverage_fout, "2636\n");
        fflush(_coverage_fout);
        }
        __z___0->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2637\n");
        fflush(_coverage_fout);
        }
        __z___0->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2640\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2641\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2670\n");
    fflush(_coverage_fout);
    }
    if (options & (long )(1 << 2)) {
      {
      fprintf(_coverage_fout, "2642\n");
      fflush(_coverage_fout);
      }
      tmp___3 = __xmlSaveNoEmptyTags();
      {
      fprintf(_coverage_fout, "2643\n");
      fflush(_coverage_fout);
      }
      saveempty = *tmp___3;
      {
      fprintf(_coverage_fout, "2644\n");
      fflush(_coverage_fout);
      }
      tmp___4 = __xmlSaveNoEmptyTags();
      {
      fprintf(_coverage_fout, "2645\n");
      fflush(_coverage_fout);
      }
      *tmp___4 = 1;
    } else {
      {
      fprintf(_coverage_fout, "2646\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2671\n");
    fflush(_coverage_fout);
    }
    xmlNodeDump(buf, docp, node, 0, format);
    {
    fprintf(_coverage_fout, "2672\n");
    fflush(_coverage_fout);
    }
    if (options & (long )(1 << 2)) {
      {
      fprintf(_coverage_fout, "2647\n");
      fflush(_coverage_fout);
      }
      tmp___5 = __xmlSaveNoEmptyTags();
      {
      fprintf(_coverage_fout, "2648\n");
      fflush(_coverage_fout);
      }
      *tmp___5 = saveempty;
    } else {
      {
      fprintf(_coverage_fout, "2649\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2673\n");
    fflush(_coverage_fout);
    }
    tmp___6 = xmlBufferContent(buf);
    {
    fprintf(_coverage_fout, "2674\n");
    fflush(_coverage_fout);
    }
    mem = (xmlChar *)tmp___6;
    {
    fprintf(_coverage_fout, "2675\n");
    fflush(_coverage_fout);
    }
    if (! mem) {
      {
      fprintf(_coverage_fout, "2653\n");
      fflush(_coverage_fout);
      }
      xmlBufferFree(buf);
      {
      fprintf(_coverage_fout, "2654\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2650\n");
        fflush(_coverage_fout);
        }
        __z___1 = return_value;
        {
        fprintf(_coverage_fout, "2651\n");
        fflush(_coverage_fout);
        }
        __z___1->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2652\n");
        fflush(_coverage_fout);
        }
        __z___1->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2655\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2656\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2676\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2657\n");
      fflush(_coverage_fout);
      }
      __s = (char const   *)mem;
      {
      fprintf(_coverage_fout, "2658\n");
      fflush(_coverage_fout);
      }
      __z___2 = return_value;
      {
      fprintf(_coverage_fout, "2659\n");
      fflush(_coverage_fout);
      }
      tmp___7 = strlen(__s);
      {
      fprintf(_coverage_fout, "2660\n");
      fflush(_coverage_fout);
      }
      __z___2->value.str.len = (int )tmp___7;
      {
      fprintf(_coverage_fout, "2661\n");
      fflush(_coverage_fout);
      }
      tmp___8 = _estrndup(__s, (unsigned int )__z___2->value.str.len);
      {
      fprintf(_coverage_fout, "2662\n");
      fflush(_coverage_fout);
      }
      __z___2->value.str.val = (char *)tmp___8;
      {
      fprintf(_coverage_fout, "2663\n");
      fflush(_coverage_fout);
      }
      __z___2->type = (unsigned char)6;
      break;
    }
    {
    fprintf(_coverage_fout, "2677\n");
    fflush(_coverage_fout);
    }
    xmlBufferFree(buf);
  } else {
    {
    fprintf(_coverage_fout, "2699\n");
    fflush(_coverage_fout);
    }
    if (options & (long )(1 << 2)) {
      {
      fprintf(_coverage_fout, "2678\n");
      fflush(_coverage_fout);
      }
      tmp___9 = __xmlSaveNoEmptyTags();
      {
      fprintf(_coverage_fout, "2679\n");
      fflush(_coverage_fout);
      }
      saveempty = *tmp___9;
      {
      fprintf(_coverage_fout, "2680\n");
      fflush(_coverage_fout);
      }
      tmp___10 = __xmlSaveNoEmptyTags();
      {
      fprintf(_coverage_fout, "2681\n");
      fflush(_coverage_fout);
      }
      *tmp___10 = 1;
    } else {
      {
      fprintf(_coverage_fout, "2682\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2700\n");
    fflush(_coverage_fout);
    }
    xmlDocDumpFormatMemory(docp, & mem, & size, format);
    {
    fprintf(_coverage_fout, "2701\n");
    fflush(_coverage_fout);
    }
    if (options & (long )(1 << 2)) {
      {
      fprintf(_coverage_fout, "2683\n");
      fflush(_coverage_fout);
      }
      tmp___11 = __xmlSaveNoEmptyTags();
      {
      fprintf(_coverage_fout, "2684\n");
      fflush(_coverage_fout);
      }
      *tmp___11 = saveempty;
    } else {
      {
      fprintf(_coverage_fout, "2685\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2702\n");
    fflush(_coverage_fout);
    }
    if (! size) {
      {
      fprintf(_coverage_fout, "2689\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2686\n");
        fflush(_coverage_fout);
        }
        __z___3 = return_value;
        {
        fprintf(_coverage_fout, "2687\n");
        fflush(_coverage_fout);
        }
        __z___3->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2688\n");
        fflush(_coverage_fout);
        }
        __z___3->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2690\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2691\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2703\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2692\n");
      fflush(_coverage_fout);
      }
      __s___0 = (char const   *)mem;
      {
      fprintf(_coverage_fout, "2693\n");
      fflush(_coverage_fout);
      }
      __l = size;
      {
      fprintf(_coverage_fout, "2694\n");
      fflush(_coverage_fout);
      }
      __z___4 = return_value;
      {
      fprintf(_coverage_fout, "2695\n");
      fflush(_coverage_fout);
      }
      __z___4->value.str.len = __l;
      {
      fprintf(_coverage_fout, "2696\n");
      fflush(_coverage_fout);
      }
      tmp___12 = _estrndup(__s___0, (unsigned int )__l);
      {
      fprintf(_coverage_fout, "2697\n");
      fflush(_coverage_fout);
      }
      __z___4->value.str.val = (char *)tmp___12;
      {
      fprintf(_coverage_fout, "2698\n");
      fflush(_coverage_fout);
      }
      __z___4->type = (unsigned char)6;
      break;
    }
    {
    fprintf(_coverage_fout, "2704\n");
    fflush(_coverage_fout);
    }
    (*xmlFree)((void *)mem);
  }
  {
  fprintf(_coverage_fout, "2716\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_savexml(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern int xmlSaveFormatFileEnc(char const   *filename , xmlDocPtr cur ,
                                char const   *encoding , int format ) ;
void zif_dom_document_save(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) 
{ zval *id ;
  xmlDoc *docp ;
  int file_len ;
  int bytes ;
  int format ;
  int saveempty ;
  dom_object *intern ;
  dom_doc_propsptr doc_props ;
  char *file ;
  long options ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int *tmp___1 ;
  int *tmp___2 ;
  int *tmp___3 ;
  zval *__z___0 ;
  zval *__z___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2588\n");
  fflush(_coverage_fout);
  }
  file_len = 0;
  {
  fprintf(_coverage_fout, "2589\n");
  fflush(_coverage_fout);
  }
  saveempty = 0;
  {
  fprintf(_coverage_fout, "2590\n");
  fflush(_coverage_fout);
  }
  options = 0L;
  {
  fprintf(_coverage_fout, "2591\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os|l", & id,
                                     dom_document_class_entry, & file,
                                     & file_len, & options);
  {
  fprintf(_coverage_fout, "2592\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2556\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2557\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2593\n");
  fflush(_coverage_fout);
  }
  if (file_len == 0) {
    {
    fprintf(_coverage_fout, "2561\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid Filename");
    {
    fprintf(_coverage_fout, "2562\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2558\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2559\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2560\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2563\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2564\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2594\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2595\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2596\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2565\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2566\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2567\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2572\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2573\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2568\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2569\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2570\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2571\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2597\n");
  fflush(_coverage_fout);
  }
  doc_props = dom_get_doc_props(intern->document);
  {
  fprintf(_coverage_fout, "2598\n");
  fflush(_coverage_fout);
  }
  format = doc_props->formatoutput;
  {
  fprintf(_coverage_fout, "2599\n");
  fflush(_coverage_fout);
  }
  if (options & (long )(1 << 2)) {
    {
    fprintf(_coverage_fout, "2574\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __xmlSaveNoEmptyTags();
    {
    fprintf(_coverage_fout, "2575\n");
    fflush(_coverage_fout);
    }
    saveempty = *tmp___1;
    {
    fprintf(_coverage_fout, "2576\n");
    fflush(_coverage_fout);
    }
    tmp___2 = __xmlSaveNoEmptyTags();
    {
    fprintf(_coverage_fout, "2577\n");
    fflush(_coverage_fout);
    }
    *tmp___2 = 1;
  } else {
    {
    fprintf(_coverage_fout, "2578\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2600\n");
  fflush(_coverage_fout);
  }
  bytes = xmlSaveFormatFileEnc((char const   *)file, docp,
                               (char const   *)((void *)0), format);
  {
  fprintf(_coverage_fout, "2601\n");
  fflush(_coverage_fout);
  }
  if (options & (long )(1 << 2)) {
    {
    fprintf(_coverage_fout, "2579\n");
    fflush(_coverage_fout);
    }
    tmp___3 = __xmlSaveNoEmptyTags();
    {
    fprintf(_coverage_fout, "2580\n");
    fflush(_coverage_fout);
    }
    *tmp___3 = saveempty;
  } else {
    {
    fprintf(_coverage_fout, "2581\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2602\n");
  fflush(_coverage_fout);
  }
  if (bytes == -1) {
    {
    fprintf(_coverage_fout, "2585\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2582\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2583\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2584\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2586\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2587\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2603\n");
  fflush(_coverage_fout);
  }
  __z___1 = return_value;
  {
  fprintf(_coverage_fout, "2604\n");
  fflush(_coverage_fout);
  }
  __z___1->value.lval = (long )bytes;
  {
  fprintf(_coverage_fout, "2605\n");
  fflush(_coverage_fout);
  }
  __z___1->type = (unsigned char)1;
  {
  fprintf(_coverage_fout, "2606\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_save(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
static void dom_parse_document(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used , int mode ) ;
void zim_domdocument_loadXML(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2554\n");
  fflush(_coverage_fout);
  }
  dom_parse_document(ht, return_value, return_value_ptr, this_ptr,
                     return_value_used, 0);
  {
  fprintf(_coverage_fout, "2555\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zim_domdocument_loadXML(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
void zim_domdocument_load(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2552\n");
  fflush(_coverage_fout);
  }
  dom_parse_document(ht, return_value, return_value_ptr, this_ptr,
                     return_value_used, 1);
  {
  fprintf(_coverage_fout, "2553\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zim_domdocument_load(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
static xmlDocPtr dom_document_parser(zval *id , int mode , char *source ,
                                     int source_len , int options ) ;
static void dom_parse_document(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used , int mode ) 
{ zval *id ;
  zval *rv ;
  xmlDoc *docp ;
  xmlDoc *newdoc ;
  dom_doc_propsptr doc_prop ;
  dom_object *intern ;
  char *source ;
  int source_len ;
  int refcount ;
  int ret ;
  long options ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zend_bool __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  zval *__z ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;
  zval *__z___2 ;
  zval *__z___3 ;
  zval __attribute__((__visibility__("default")))  *tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2540\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "2541\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)((void *)0);
  {
  fprintf(_coverage_fout, "2542\n");
  fflush(_coverage_fout);
  }
  options = 0L;
  {
  fprintf(_coverage_fout, "2543\n");
  fflush(_coverage_fout);
  }
  id = this_ptr;
  {
  fprintf(_coverage_fout, "2544\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )id != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2478\n");
    fflush(_coverage_fout);
    }
    tmp = zend_get_class_entry((zval const   *)id);
    {
    fprintf(_coverage_fout, "2479\n");
    fflush(_coverage_fout);
    }
    tmp___0 = instanceof_function((zend_class_entry const   *)tmp,
                                  (zend_class_entry const   *)dom_document_class_entry);
    {
    fprintf(_coverage_fout, "2480\n");
    fflush(_coverage_fout);
    }
    if (tmp___0) {
      {
      fprintf(_coverage_fout, "2476\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2477\n");
      fflush(_coverage_fout);
      }
      id = (zval *)((void *)0);
    }
  } else {
    {
    fprintf(_coverage_fout, "2481\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2545\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_parse_parameters(ht, "s|l", & source, & source_len, & options);
  {
  fprintf(_coverage_fout, "2546\n");
  fflush(_coverage_fout);
  }
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2482\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2483\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2547\n");
  fflush(_coverage_fout);
  }
  if (! source_len) {
    {
    fprintf(_coverage_fout, "2487\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Empty string supplied as input");
    {
    fprintf(_coverage_fout, "2488\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2484\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2485\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2486\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2489\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2490\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2548\n");
  fflush(_coverage_fout);
  }
  newdoc = dom_document_parser(id, mode, source, source_len, (int )options);
  {
  fprintf(_coverage_fout, "2549\n");
  fflush(_coverage_fout);
  }
  if (! newdoc) {
    {
    fprintf(_coverage_fout, "2494\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2491\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2492\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2493\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2495\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2496\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2550\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )id != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2524\n");
    fflush(_coverage_fout);
    }
    tmp___2 = zend_object_store_get_object((zval const   *)id);
    {
    fprintf(_coverage_fout, "2525\n");
    fflush(_coverage_fout);
    }
    intern = (dom_object *)tmp___2;
    {
    fprintf(_coverage_fout, "2526\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )intern != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "2512\n");
      fflush(_coverage_fout);
      }
      tmp___3 = dom_object_get_node(intern);
      {
      fprintf(_coverage_fout, "2513\n");
      fflush(_coverage_fout);
      }
      docp = (xmlDoc *)tmp___3;
      {
      fprintf(_coverage_fout, "2514\n");
      fflush(_coverage_fout);
      }
      doc_prop = (libxml_doc_props *)((void *)0);
      {
      fprintf(_coverage_fout, "2515\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )docp != (unsigned int )((void *)0)) {
        {
        fprintf(_coverage_fout, "2499\n");
        fflush(_coverage_fout);
        }
        php_libxml_decrement_node_ptr((php_libxml_node_object *)intern);
        {
        fprintf(_coverage_fout, "2500\n");
        fflush(_coverage_fout);
        }
        doc_prop = (intern->document)->doc_props;
        {
        fprintf(_coverage_fout, "2501\n");
        fflush(_coverage_fout);
        }
        (intern->document)->doc_props = (libxml_doc_props *)((void *)0);
        {
        fprintf(_coverage_fout, "2502\n");
        fflush(_coverage_fout);
        }
        tmp___4 = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
        {
        fprintf(_coverage_fout, "2503\n");
        fflush(_coverage_fout);
        }
        refcount = (int )tmp___4;
        {
        fprintf(_coverage_fout, "2504\n");
        fflush(_coverage_fout);
        }
        if (refcount != 0) {
          {
          fprintf(_coverage_fout, "2497\n");
          fflush(_coverage_fout);
          }
          docp->_private = (void *)0;
        } else {
          {
          fprintf(_coverage_fout, "2498\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "2505\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "2516\n");
      fflush(_coverage_fout);
      }
      intern->document = (php_libxml_ref_obj *)((void *)0);
      {
      fprintf(_coverage_fout, "2517\n");
      fflush(_coverage_fout);
      }
      tmp___5 = php_libxml_increment_doc_ref((php_libxml_node_object *)intern,
                                             newdoc);
      {
      fprintf(_coverage_fout, "2518\n");
      fflush(_coverage_fout);
      }
      if (tmp___5 == (int __attribute__((__visibility__("default")))  )-1) {
        {
        fprintf(_coverage_fout, "2509\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "2506\n");
          fflush(_coverage_fout);
          }
          __z___1 = return_value;
          {
          fprintf(_coverage_fout, "2507\n");
          fflush(_coverage_fout);
          }
          __z___1->value.lval = 0L;
          {
          fprintf(_coverage_fout, "2508\n");
          fflush(_coverage_fout);
          }
          __z___1->type = (unsigned char)3;
          break;
        }
        {
        fprintf(_coverage_fout, "2510\n");
        fflush(_coverage_fout);
        }
        return;
      } else {
        {
        fprintf(_coverage_fout, "2511\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "2519\n");
      fflush(_coverage_fout);
      }
      (intern->document)->doc_props = doc_prop;
    } else {
      {
      fprintf(_coverage_fout, "2520\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2527\n");
    fflush(_coverage_fout);
    }
    php_libxml_increment_node_ptr((php_libxml_node_object *)intern,
                                  (xmlNode *)newdoc, (void *)intern);
    {
    fprintf(_coverage_fout, "2528\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2521\n");
      fflush(_coverage_fout);
      }
      __z___2 = return_value;
      {
      fprintf(_coverage_fout, "2522\n");
      fflush(_coverage_fout);
      }
      __z___2->value.lval = 1L;
      {
      fprintf(_coverage_fout, "2523\n");
      fflush(_coverage_fout);
      }
      __z___2->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2529\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2537\n");
    fflush(_coverage_fout);
    }
    tmp___6 = php_dom_create_object((xmlNode *)newdoc, & ret, rv, return_value,
                                    (dom_object *)((void *)0));
    {
    fprintf(_coverage_fout, "2538\n");
    fflush(_coverage_fout);
    }
    rv = (zval *)tmp___6;
    {
    fprintf(_coverage_fout, "2539\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )((void *)0) == (unsigned int )rv) {
      {
      fprintf(_coverage_fout, "2533\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Cannot create required DOM object");
      {
      fprintf(_coverage_fout, "2534\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2530\n");
        fflush(_coverage_fout);
        }
        __z___3 = return_value;
        {
        fprintf(_coverage_fout, "2531\n");
        fflush(_coverage_fout);
        }
        __z___3->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2532\n");
        fflush(_coverage_fout);
        }
        __z___3->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2535\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2536\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "2551\n");
  fflush(_coverage_fout);
  }
  return;
}
}
extern void xmlFreeParserCtxt(xmlParserCtxtPtr ctxt ) ;
extern void xmlFreeDoc(xmlDocPtr cur ) ;
extern xmlChar *xmlStrdup(xmlChar const   *cur ) ;
struct _zend_executor_globals;
typedef struct _zend_executor_globals zend_executor_globals;
extern zend_executor_globals __attribute__((__visibility__("default")))  executor_globals ;
typedef unsigned short fpu_control_t;
struct _zend_op;
typedef struct _zend_op zend_op;
struct _zend_property_info {
   zend_uint flags ;
   char *name ;
   int name_length ;
   ulong h ;
   int offset ;
   char *doc_comment ;
   int doc_comment_len ;
   zend_class_entry *ce ;
};
typedef struct _zend_property_info zend_property_info;
struct _zend_execute_data;
struct _zend_literal;
typedef struct _zend_literal zend_literal;
typedef unsigned long zend_ulong;
union _znode_op {
   zend_uint constant ;
   zend_uint var ;
   zend_uint num ;
   zend_ulong hash ;
   zend_uint opline_num ;
   zend_op *jmp_addr ;
   zval *zv ;
   zend_literal *literal ;
   void *ptr ;
};
typedef union _znode_op znode_op;
typedef struct _zend_execute_data zend_execute_data;
struct _zend_op {
   int ( __attribute__((__fastcall__)) (*handler))(zend_execute_data *execute_data ) ;
   znode_op op1 ;
   znode_op op2 ;
   znode_op result ;
   ulong extended_value ;
   uint lineno ;
   zend_uchar opcode ;
   zend_uchar op1_type ;
   zend_uchar op2_type ;
   zend_uchar result_type ;
};
struct _zend_object_store_bucket;
typedef struct _zend_object_store_bucket zend_object_store_bucket;
struct _zend_objects_store {
   zend_object_store_bucket *object_buckets ;
   zend_uint top ;
   zend_uint size ;
   int free_list_head ;
};
typedef struct _zend_objects_store zend_objects_store;
struct _zend_ini_entry;
typedef struct _zend_ini_entry zend_ini_entry;
enum __anonenum_zend_error_handling_t_47 {
    EH_NORMAL = 0,
    EH_SUPPRESS = 1,
    EH_THROW = 2
} ;
typedef enum __anonenum_zend_error_handling_t_47 zend_error_handling_t;
struct _zend_ptr_stack {
   int top ;
   int max ;
   void **elements ;
   void **top_element ;
   zend_bool persistent ;
};
typedef struct _zend_ptr_stack zend_ptr_stack;
struct _zend_stack {
   int top ;
   int max ;
   void **elements ;
};
typedef struct _zend_stack zend_stack;
struct _zend_vm_stack;
typedef struct _zend_vm_stack *zend_vm_stack;
typedef union _zend_function zend_function;
struct _zend_op_array;
typedef struct _zend_op_array zend_op_array;
struct __anonstruct___sigset_t_8 {
   unsigned long __val[1024U / (8U * sizeof(unsigned long ))] ;
};
typedef struct __anonstruct___sigset_t_8 __sigset_t;
typedef int __jmp_buf[6];
struct __jmp_buf_tag {
   __jmp_buf __jmpbuf ;
   int __mask_was_saved ;
   __sigset_t __saved_mask ;
};
typedef struct __jmp_buf_tag jmp_buf[1];
struct _zend_executor_globals {
   zval **return_value_ptr_ptr ;
   zval uninitialized_zval ;
   zval *uninitialized_zval_ptr ;
   zval error_zval ;
   zval *error_zval_ptr ;
   zend_ptr_stack arg_types_stack ;
   HashTable *symtable_cache[32] ;
   HashTable **symtable_cache_limit ;
   HashTable **symtable_cache_ptr ;
   zend_op **opline_ptr ;
   HashTable *active_symbol_table ;
   HashTable symbol_table ;
   HashTable included_files ;
   jmp_buf *bailout ;
   int error_reporting ;
   int orig_error_reporting ;
   int exit_status ;
   zend_op_array *active_op_array ;
   HashTable *function_table ;
   HashTable *class_table ;
   HashTable *zend_constants ;
   zend_class_entry *scope ;
   zend_class_entry *called_scope ;
   zval *This ;
   long precision ;
   int ticks_count ;
   zend_bool in_execution ;
   HashTable *in_autoload ;
   zend_function *autoload_func ;
   zend_bool full_tables_cleanup ;
   zend_bool no_extensions ;
   HashTable regular_list ;
   HashTable persistent_list ;
   zend_vm_stack argument_stack ;
   int user_error_handler_error_reporting ;
   zval *user_error_handler ;
   zval *user_exception_handler ;
   zend_stack user_error_handlers_error_reporting ;
   zend_ptr_stack user_error_handlers ;
   zend_ptr_stack user_exception_handlers ;
   zend_error_handling_t error_handling ;
   zend_class_entry *exception_class ;
   int timeout_seconds ;
   int lambda_count ;
   HashTable *ini_directives ;
   HashTable *modified_ini_directives ;
   zend_ini_entry *error_reporting_ini_entry ;
   zend_objects_store objects_store ;
   zval *exception ;
   zval *prev_exception ;
   zend_op *opline_before_exception ;
   zend_op exception_op[3] ;
   struct _zend_execute_data *current_execute_data ;
   struct _zend_module_entry *current_module ;
   zend_property_info std_property_info ;
   zend_bool active ;
   zend_op *start_op ;
   void *saved_fpu_cw_ptr ;
   fpu_control_t saved_fpu_cw ;
   void *reserved[4] ;
};
extern int xmlParseDocument(xmlParserCtxtPtr ctxt ) ;
extern int xmlCtxtUseOptions(xmlParserCtxtPtr ctxt , int options ) ;
extern xmlChar *xmlCanonicPath(xmlChar const   *path ) ;
extern  __attribute__((__nothrow__)) char *getcwd(char *__buf , size_t __size ) ;
extern xmlParserCtxtPtr xmlCreateMemoryParserCtxt(char const   *buffer ,
                                                  int size ) ;
extern xmlParserCtxtPtr xmlCreateFileParserCtxt(char const   *filename ) ;
extern void xmlInitParser(void) ;
extern void __attribute__((__visibility__("default")))  _efree(void *ptr ) ;
static xmlDocPtr dom_document_parser(zval *id , int mode , char *source ,
                                     int source_len , int options ) 
{ xmlDocPtr ret ;
  xmlParserCtxtPtr ctxt ;
  dom_doc_propsptr doc_props ;
  dom_object *intern ;
  php_libxml_ref_obj *document ;
  int validate ;
  int recover ;
  int resolve_externals ;
  int keep_blanks ;
  int substitute_ent ;
  int resolved_path_len ;
  int old_error_reporting ;
  char *directory ;
  char resolved_path[4096] ;
  void __attribute__((__visibility__("default")))  *tmp ;
  char *file_dest ;
  char *tmp___0 ;
  size_t tmp___1 ;
  xmlChar *tmp___2 ;
  xmlChar *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2446\n");
  fflush(_coverage_fout);
  }
  ctxt = (xmlParserCtxtPtr )((void *)0);
  {
  fprintf(_coverage_fout, "2447\n");
  fflush(_coverage_fout);
  }
  document = (php_libxml_ref_obj *)((void *)0);
  {
  fprintf(_coverage_fout, "2448\n");
  fflush(_coverage_fout);
  }
  old_error_reporting = 0;
  {
  fprintf(_coverage_fout, "2449\n");
  fflush(_coverage_fout);
  }
  directory = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2450\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )id != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2378\n");
    fflush(_coverage_fout);
    }
    tmp = zend_object_store_get_object((zval const   *)id);
    {
    fprintf(_coverage_fout, "2379\n");
    fflush(_coverage_fout);
    }
    intern = (dom_object *)tmp;
    {
    fprintf(_coverage_fout, "2380\n");
    fflush(_coverage_fout);
    }
    document = intern->document;
  } else {
    {
    fprintf(_coverage_fout, "2381\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2451\n");
  fflush(_coverage_fout);
  }
  doc_props = dom_get_doc_props(document);
  {
  fprintf(_coverage_fout, "2452\n");
  fflush(_coverage_fout);
  }
  validate = doc_props->validateonparse;
  {
  fprintf(_coverage_fout, "2453\n");
  fflush(_coverage_fout);
  }
  resolve_externals = doc_props->resolveexternals;
  {
  fprintf(_coverage_fout, "2454\n");
  fflush(_coverage_fout);
  }
  keep_blanks = doc_props->preservewhitespace;
  {
  fprintf(_coverage_fout, "2455\n");
  fflush(_coverage_fout);
  }
  substitute_ent = doc_props->substituteentities;
  {
  fprintf(_coverage_fout, "2456\n");
  fflush(_coverage_fout);
  }
  recover = doc_props->recover;
  {
  fprintf(_coverage_fout, "2457\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )document == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2382\n");
    fflush(_coverage_fout);
    }
    _efree((void *)doc_props);
  } else {
    {
    fprintf(_coverage_fout, "2383\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2458\n");
  fflush(_coverage_fout);
  }
  xmlInitParser();
  {
  fprintf(_coverage_fout, "2459\n");
  fflush(_coverage_fout);
  }
  if (mode == 1) {
    {
    fprintf(_coverage_fout, "2386\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _dom_get_valid_file_path(source, resolved_path, 4096);
    {
    fprintf(_coverage_fout, "2387\n");
    fflush(_coverage_fout);
    }
    file_dest = tmp___0;
    {
    fprintf(_coverage_fout, "2388\n");
    fflush(_coverage_fout);
    }
    if (file_dest) {
      {
      fprintf(_coverage_fout, "2384\n");
      fflush(_coverage_fout);
      }
      ctxt = xmlCreateFileParserCtxt((char const   *)file_dest);
    } else {
      {
      fprintf(_coverage_fout, "2385\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2389\n");
    fflush(_coverage_fout);
    }
    ctxt = xmlCreateMemoryParserCtxt((char const   *)source, source_len);
  }
  {
  fprintf(_coverage_fout, "2460\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )ctxt == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2390\n");
    fflush(_coverage_fout);
    }
    return ((xmlDoc *)((void *)0));
  } else {
    {
    fprintf(_coverage_fout, "2391\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2461\n");
  fflush(_coverage_fout);
  }
  if (mode != 1) {
    {
    fprintf(_coverage_fout, "2405\n");
    fflush(_coverage_fout);
    }
    directory = getcwd(resolved_path, 4096U);
    {
    fprintf(_coverage_fout, "2406\n");
    fflush(_coverage_fout);
    }
    if (directory) {
      {
      fprintf(_coverage_fout, "2398\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )ctxt->directory != (unsigned int )((void *)0)) {
        {
        fprintf(_coverage_fout, "2392\n");
        fflush(_coverage_fout);
        }
        (*xmlFree)((void *)ctxt->directory);
      } else {
        {
        fprintf(_coverage_fout, "2393\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "2399\n");
      fflush(_coverage_fout);
      }
      tmp___1 = strlen((char const   *)(resolved_path));
      {
      fprintf(_coverage_fout, "2400\n");
      fflush(_coverage_fout);
      }
      resolved_path_len = (int )tmp___1;
      {
      fprintf(_coverage_fout, "2401\n");
      fflush(_coverage_fout);
      }
      if ((int )resolved_path[resolved_path_len - 1] != 47) {
        {
        fprintf(_coverage_fout, "2394\n");
        fflush(_coverage_fout);
        }
        resolved_path[resolved_path_len] = (char )'/';
        {
        fprintf(_coverage_fout, "2395\n");
        fflush(_coverage_fout);
        }
        resolved_path_len ++;
        {
        fprintf(_coverage_fout, "2396\n");
        fflush(_coverage_fout);
        }
        resolved_path[resolved_path_len] = (char )'\000';
      } else {
        {
        fprintf(_coverage_fout, "2397\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "2402\n");
      fflush(_coverage_fout);
      }
      tmp___2 = xmlCanonicPath((xmlChar const   *)(resolved_path));
      {
      fprintf(_coverage_fout, "2403\n");
      fflush(_coverage_fout);
      }
      ctxt->directory = (char *)tmp___2;
    } else {
      {
      fprintf(_coverage_fout, "2404\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2407\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2462\n");
  fflush(_coverage_fout);
  }
  ctxt->vctxt.error = (void ( /* format attribute */  (*))(void *ctx ,
                                                           char const   *msg 
                                                           , ...))(& php_libxml_ctx_error);
  {
  fprintf(_coverage_fout, "2463\n");
  fflush(_coverage_fout);
  }
  ctxt->vctxt.warning = (void ( /* format attribute */  (*))(void *ctx ,
                                                             char const   *msg 
                                                             , ...))(& php_libxml_ctx_warning);
  {
  fprintf(_coverage_fout, "2464\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )ctxt->sax != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2408\n");
    fflush(_coverage_fout);
    }
    (ctxt->sax)->error = (void ( /* format attribute */  (*))(void *ctx ,
                                                              char const   *msg 
                                                              , ...))(& php_libxml_ctx_error);
    {
    fprintf(_coverage_fout, "2409\n");
    fflush(_coverage_fout);
    }
    (ctxt->sax)->warning = (void ( /* format attribute */  (*))(void *ctx ,
                                                                char const   *msg 
                                                                , ...))(& php_libxml_ctx_warning);
  } else {
    {
    fprintf(_coverage_fout, "2410\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2465\n");
  fflush(_coverage_fout);
  }
  if (validate) {
    {
    fprintf(_coverage_fout, "2413\n");
    fflush(_coverage_fout);
    }
    if (! (options & 16)) {
      {
      fprintf(_coverage_fout, "2411\n");
      fflush(_coverage_fout);
      }
      options |= 16;
    } else {
      {
      fprintf(_coverage_fout, "2412\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2414\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2466\n");
  fflush(_coverage_fout);
  }
  if (resolve_externals) {
    {
    fprintf(_coverage_fout, "2417\n");
    fflush(_coverage_fout);
    }
    if (! (options & 8)) {
      {
      fprintf(_coverage_fout, "2415\n");
      fflush(_coverage_fout);
      }
      options |= 8;
    } else {
      {
      fprintf(_coverage_fout, "2416\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2418\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2467\n");
  fflush(_coverage_fout);
  }
  if (substitute_ent) {
    {
    fprintf(_coverage_fout, "2421\n");
    fflush(_coverage_fout);
    }
    if (! (options & 2)) {
      {
      fprintf(_coverage_fout, "2419\n");
      fflush(_coverage_fout);
      }
      options |= 2;
    } else {
      {
      fprintf(_coverage_fout, "2420\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2422\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2468\n");
  fflush(_coverage_fout);
  }
  if (keep_blanks == 0) {
    {
    fprintf(_coverage_fout, "2425\n");
    fflush(_coverage_fout);
    }
    if (! (options & 256)) {
      {
      fprintf(_coverage_fout, "2423\n");
      fflush(_coverage_fout);
      }
      options |= 256;
    } else {
      {
      fprintf(_coverage_fout, "2424\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2426\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2469\n");
  fflush(_coverage_fout);
  }
  xmlCtxtUseOptions(ctxt, options);
  {
  fprintf(_coverage_fout, "2470\n");
  fflush(_coverage_fout);
  }
  ctxt->recovery = recover;
  {
  fprintf(_coverage_fout, "2471\n");
  fflush(_coverage_fout);
  }
  if (recover) {
    {
    fprintf(_coverage_fout, "2427\n");
    fflush(_coverage_fout);
    }
    old_error_reporting = executor_globals.error_reporting;
    {
    fprintf(_coverage_fout, "2428\n");
    fflush(_coverage_fout);
    }
    executor_globals.error_reporting = old_error_reporting | (1 << 1L);
  } else {
    {
    fprintf(_coverage_fout, "2429\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2472\n");
  fflush(_coverage_fout);
  }
  xmlParseDocument(ctxt);
  {
  fprintf(_coverage_fout, "2473\n");
  fflush(_coverage_fout);
  }
  if (ctxt->wellFormed) {
    goto _L;
  } else {
    {
    fprintf(_coverage_fout, "2445\n");
    fflush(_coverage_fout);
    }
    if (recover) {
      {
      fprintf(_coverage_fout, "2439\n");
      fflush(_coverage_fout);
      }
      _L: /* CIL Label */ 
      ret = ctxt->myDoc;
      {
      fprintf(_coverage_fout, "2440\n");
      fflush(_coverage_fout);
      }
      if (ctxt->recovery) {
        {
        fprintf(_coverage_fout, "2430\n");
        fflush(_coverage_fout);
        }
        executor_globals.error_reporting = old_error_reporting;
      } else {
        {
        fprintf(_coverage_fout, "2431\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "2441\n");
      fflush(_coverage_fout);
      }
      if (ret) {
        {
        fprintf(_coverage_fout, "2437\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )ret->URL == (unsigned int )((void *)0)) {
          {
          fprintf(_coverage_fout, "2435\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )ctxt->directory != (unsigned int )((void *)0)) {
            {
            fprintf(_coverage_fout, "2432\n");
            fflush(_coverage_fout);
            }
            tmp___3 = xmlStrdup((xmlChar const   *)ctxt->directory);
            {
            fprintf(_coverage_fout, "2433\n");
            fflush(_coverage_fout);
            }
            ret->URL = (xmlChar const   *)tmp___3;
          } else {
            {
            fprintf(_coverage_fout, "2434\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "2436\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "2438\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2442\n");
      fflush(_coverage_fout);
      }
      ret = (xmlDoc *)((void *)0);
      {
      fprintf(_coverage_fout, "2443\n");
      fflush(_coverage_fout);
      }
      xmlFreeDoc(ctxt->myDoc);
      {
      fprintf(_coverage_fout, "2444\n");
      fflush(_coverage_fout);
      }
      ctxt->myDoc = (xmlDoc *)((void *)0);
    }
  }
  {
  fprintf(_coverage_fout, "2474\n");
  fflush(_coverage_fout);
  }
  xmlFreeParserCtxt(ctxt);
  {
  fprintf(_coverage_fout, "2475\n");
  fflush(_coverage_fout);
  }
  return (ret);
}
}
struct _xmlURI;
typedef struct _xmlURI xmlURI;
typedef xmlURI *xmlURIPtr;
extern void xmlFreeURI(xmlURIPtr uri ) ;
extern char __attribute__((__visibility__("default")))  *expand_filepath(char const   *filepath ,
                                                                         char *real_path ) ;
extern char __attribute__((__visibility__("default")))  *tsrm_realpath(char const   *path ,
                                                                       char *real_path ) ;
struct _xmlURI {
   char *scheme ;
   char *opaque ;
   char *authority ;
   char *server ;
   char *user ;
   int port ;
   char *path ;
   char *query ;
   char *fragment ;
   int cleanup ;
   char *query_raw ;
};
extern  __attribute__((__nothrow__)) int strncasecmp(char const   *__s1 ,
                                                     char const   *__s2 ,
                                                     size_t __n )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern int xmlParseURIReference(xmlURIPtr uri , char const   *str ) ;
extern xmlChar *xmlURIEscapeStr(xmlChar const   *str , xmlChar const   *list ) ;
extern xmlURIPtr xmlCreateURI(void) ;
char *_dom_get_valid_file_path(char *source , char *resolved_path ,
                               int resolved_path_len ) 
{ xmlURI *uri ;
  xmlChar *escsource ;
  char *file_dest ;
  int isFileUri ;
  int tmp ;
  int tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2368\n");
  fflush(_coverage_fout);
  }
  isFileUri = 0;
  {
  fprintf(_coverage_fout, "2369\n");
  fflush(_coverage_fout);
  }
  uri = xmlCreateURI();
  {
  fprintf(_coverage_fout, "2370\n");
  fflush(_coverage_fout);
  }
  escsource = xmlURIEscapeStr((xmlChar const   *)source, (xmlChar const   *)":");
  {
  fprintf(_coverage_fout, "2371\n");
  fflush(_coverage_fout);
  }
  xmlParseURIReference(uri, (char const   *)escsource);
  {
  fprintf(_coverage_fout, "2372\n");
  fflush(_coverage_fout);
  }
  (*xmlFree)((void *)escsource);
  {
  fprintf(_coverage_fout, "2373\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )uri->scheme != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2354\n");
    fflush(_coverage_fout);
    }
    tmp___0 = strncasecmp((char const   *)source, "file:///", 8U);
    {
    fprintf(_coverage_fout, "2355\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 == 0) {
      {
      fprintf(_coverage_fout, "2347\n");
      fflush(_coverage_fout);
      }
      isFileUri = 1;
      {
      fprintf(_coverage_fout, "2348\n");
      fflush(_coverage_fout);
      }
      source += 7;
    } else {
      {
      fprintf(_coverage_fout, "2352\n");
      fflush(_coverage_fout);
      }
      tmp = strncasecmp((char const   *)source, "file://localhost/", 17U);
      {
      fprintf(_coverage_fout, "2353\n");
      fflush(_coverage_fout);
      }
      if (tmp == 0) {
        {
        fprintf(_coverage_fout, "2349\n");
        fflush(_coverage_fout);
        }
        isFileUri = 1;
        {
        fprintf(_coverage_fout, "2350\n");
        fflush(_coverage_fout);
        }
        source += 16;
      } else {
        {
        fprintf(_coverage_fout, "2351\n");
        fflush(_coverage_fout);
        }

      }
    }
  } else {
    {
    fprintf(_coverage_fout, "2356\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2374\n");
  fflush(_coverage_fout);
  }
  file_dest = source;
  {
  fprintf(_coverage_fout, "2375\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )uri->scheme == (unsigned int )((void *)0)) {
    goto _L;
  } else {
    {
    fprintf(_coverage_fout, "2367\n");
    fflush(_coverage_fout);
    }
    if (isFileUri) {
      {
      fprintf(_coverage_fout, "2363\n");
      fflush(_coverage_fout);
      }
      _L: /* CIL Label */ 
      tmp___1 = tsrm_realpath((char const   *)source, resolved_path);
      {
      fprintf(_coverage_fout, "2364\n");
      fflush(_coverage_fout);
      }
      if (tmp___1) {
        {
        fprintf(_coverage_fout, "2357\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "2361\n");
        fflush(_coverage_fout);
        }
        tmp___2 = expand_filepath((char const   *)source, resolved_path);
        {
        fprintf(_coverage_fout, "2362\n");
        fflush(_coverage_fout);
        }
        if (tmp___2) {
          {
          fprintf(_coverage_fout, "2358\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "2359\n");
          fflush(_coverage_fout);
          }
          xmlFreeURI(uri);
          {
          fprintf(_coverage_fout, "2360\n");
          fflush(_coverage_fout);
          }
          return ((char *)((void *)0));
        }
      }
      {
      fprintf(_coverage_fout, "2365\n");
      fflush(_coverage_fout);
      }
      file_dest = resolved_path;
    } else {
      {
      fprintf(_coverage_fout, "2366\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "2376\n");
  fflush(_coverage_fout);
  }
  xmlFreeURI(uri);
  {
  fprintf(_coverage_fout, "2377\n");
  fflush(_coverage_fout);
  }
  return (file_dest);
}
}
extern xmlDocPtr xmlNewDoc(xmlChar const   *version ) ;
struct __anonstruct_zend_error_handling_48 {
   zend_error_handling_t handling ;
   zend_class_entry *exception ;
   zval *user_handler ;
};
typedef struct __anonstruct_zend_error_handling_48 zend_error_handling;
struct __anonstruct_zend_error_handling_48;
extern void __attribute__((__visibility__("default")))  zend_restore_error_handling(zend_error_handling *saved ) ;
extern zend_class_entry *dom_domexception_class_entry ;
enum __anonenum_zend_error_handling_t_47;
extern void __attribute__((__visibility__("default")))  zend_replace_error_handling(zend_error_handling_t error_handling ,
                                                                                    zend_class_entry *exception_class ,
                                                                                    zend_error_handling *current ) ;
void zim_domdocument___construct(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) 
{ zval *id ;
  xmlDoc *docp ;
  xmlDoc *olddoc ;
  dom_object *intern ;
  char *encoding ;
  char *version ;
  int encoding_len ;
  int version_len ;
  int refcount ;
  zend_error_handling error_handling ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  xmlChar *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp___2 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;
  zval *__z___0 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2332\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)((void *)0);
  {
  fprintf(_coverage_fout, "2333\n");
  fflush(_coverage_fout);
  }
  version = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2334\n");
  fflush(_coverage_fout);
  }
  encoding_len = 0;
  {
  fprintf(_coverage_fout, "2335\n");
  fflush(_coverage_fout);
  }
  version_len = 0;
  {
  fprintf(_coverage_fout, "2336\n");
  fflush(_coverage_fout);
  }
  zend_replace_error_handling((enum __anonenum_zend_error_handling_t_47 )2,
                              dom_domexception_class_entry, & error_handling);
  {
  fprintf(_coverage_fout, "2337\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O|ss", & id,
                                     dom_document_class_entry, & version,
                                     & version_len, & encoding, & encoding_len);
  {
  fprintf(_coverage_fout, "2338\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2298\n");
    fflush(_coverage_fout);
    }
    zend_restore_error_handling(& error_handling);
    {
    fprintf(_coverage_fout, "2299\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2300\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2339\n");
  fflush(_coverage_fout);
  }
  zend_restore_error_handling(& error_handling);
  {
  fprintf(_coverage_fout, "2340\n");
  fflush(_coverage_fout);
  }
  docp = xmlNewDoc((xmlChar const   *)version);
  {
  fprintf(_coverage_fout, "2341\n");
  fflush(_coverage_fout);
  }
  if (! docp) {
    {
    fprintf(_coverage_fout, "2304\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 1);
    {
    fprintf(_coverage_fout, "2305\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2301\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2302\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2303\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2306\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2307\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2342\n");
  fflush(_coverage_fout);
  }
  if (encoding_len > 0) {
    {
    fprintf(_coverage_fout, "2308\n");
    fflush(_coverage_fout);
    }
    tmp___0 = xmlStrdup((xmlChar const   *)encoding);
    {
    fprintf(_coverage_fout, "2309\n");
    fflush(_coverage_fout);
    }
    docp->encoding = (xmlChar const   *)tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "2310\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2343\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2344\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___1;
  {
  fprintf(_coverage_fout, "2345\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2324\n");
    fflush(_coverage_fout);
    }
    tmp___2 = dom_object_get_node(intern);
    {
    fprintf(_coverage_fout, "2325\n");
    fflush(_coverage_fout);
    }
    olddoc = (xmlDoc *)tmp___2;
    {
    fprintf(_coverage_fout, "2326\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )olddoc != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "2313\n");
      fflush(_coverage_fout);
      }
      php_libxml_decrement_node_ptr((php_libxml_node_object *)intern);
      {
      fprintf(_coverage_fout, "2314\n");
      fflush(_coverage_fout);
      }
      tmp___3 = php_libxml_decrement_doc_ref((php_libxml_node_object *)intern);
      {
      fprintf(_coverage_fout, "2315\n");
      fflush(_coverage_fout);
      }
      refcount = (int )tmp___3;
      {
      fprintf(_coverage_fout, "2316\n");
      fflush(_coverage_fout);
      }
      if (refcount != 0) {
        {
        fprintf(_coverage_fout, "2311\n");
        fflush(_coverage_fout);
        }
        olddoc->_private = (void *)0;
      } else {
        {
        fprintf(_coverage_fout, "2312\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2317\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2327\n");
    fflush(_coverage_fout);
    }
    intern->document = (php_libxml_ref_obj *)((void *)0);
    {
    fprintf(_coverage_fout, "2328\n");
    fflush(_coverage_fout);
    }
    tmp___4 = php_libxml_increment_doc_ref((php_libxml_node_object *)intern,
                                           docp);
    {
    fprintf(_coverage_fout, "2329\n");
    fflush(_coverage_fout);
    }
    if (tmp___4 == (int __attribute__((__visibility__("default")))  )-1) {
      {
      fprintf(_coverage_fout, "2321\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2318\n");
        fflush(_coverage_fout);
        }
        __z___0 = return_value;
        {
        fprintf(_coverage_fout, "2319\n");
        fflush(_coverage_fout);
        }
        __z___0->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2320\n");
        fflush(_coverage_fout);
        }
        __z___0->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2322\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2323\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2330\n");
    fflush(_coverage_fout);
    }
    php_libxml_increment_node_ptr((php_libxml_node_object *)intern,
                                  (xmlNode *)docp, (void *)intern);
  } else {
    {
    fprintf(_coverage_fout, "2331\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2346\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zim_domdocument___construct(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
void zif_dom_document_rename_node(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2296\n");
  fflush(_coverage_fout);
  }
  php_error_docref0((char const   *)((void *)0), 1 << 1L, "Not yet implemented");
  {
  fprintf(_coverage_fout, "2297\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_rename_node(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void dom_normalize(xmlNodePtr nodep ) ;
void zif_dom_document_normalize_document(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) 
{ zval *id ;
  xmlDocPtr docp ;
  dom_object *intern ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2289\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & id,
                                     dom_document_class_entry);
  {
  fprintf(_coverage_fout, "2290\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2278\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2279\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2291\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2292\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2293\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2280\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2281\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2282\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2287\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2288\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2283\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2284\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2285\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2286\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2294\n");
  fflush(_coverage_fout);
  }
  dom_normalize((xmlNode *)docp);
  {
  fprintf(_coverage_fout, "2295\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_normalize_document(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) ;
void zif_dom_document_adopt_node(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2276\n");
  fflush(_coverage_fout);
  }
  php_error_docref0((char const   *)((void *)0), 1 << 1L, "Not yet implemented");
  {
  fprintf(_coverage_fout, "2277\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_adopt_node(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
enum __anonenum_xmlAttributeType_82 {
    XML_ATTRIBUTE_CDATA = 1,
    XML_ATTRIBUTE_ID = 2,
    XML_ATTRIBUTE_IDREF = 3,
    XML_ATTRIBUTE_IDREFS = 4,
    XML_ATTRIBUTE_ENTITY = 5,
    XML_ATTRIBUTE_ENTITIES = 6,
    XML_ATTRIBUTE_NMTOKEN = 7,
    XML_ATTRIBUTE_NMTOKENS = 8,
    XML_ATTRIBUTE_ENUMERATION = 9,
    XML_ATTRIBUTE_NOTATION = 10
} ;
typedef enum __anonenum_xmlAttributeType_82 xmlAttributeType;
struct _xmlAttr {
   void *_private ;
   xmlElementType type ;
   xmlChar const   *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlNode *parent ;
   struct _xmlAttr *next ;
   struct _xmlAttr *prev ;
   struct _xmlDoc *doc ;
   xmlNs *ns ;
   xmlAttributeType atype ;
   void *psvi ;
};
extern xmlAttrPtr xmlGetID(xmlDocPtr doc , xmlChar const   *ID ) ;
void zif_dom_document_get_element_by_id(int ht , zval *return_value ,
                                        zval **return_value_ptr ,
                                        zval *this_ptr , int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlDocPtr docp ;
  xmlAttrPtr attrp ;
  int ret ;
  int idname_len ;
  dom_object *intern ;
  char *idname ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2267\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "2268\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & idname,
                                     & idname_len);
  {
  fprintf(_coverage_fout, "2269\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2243\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2244\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2270\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2271\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2272\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2245\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2246\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2247\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2252\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2253\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2248\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2249\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2250\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2251\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2273\n");
  fflush(_coverage_fout);
  }
  attrp = xmlGetID(docp, (xmlChar const   *)((xmlChar *)idname));
  {
  fprintf(_coverage_fout, "2274\n");
  fflush(_coverage_fout);
  }
  if (attrp) {
    {
    fprintf(_coverage_fout, "2265\n");
    fflush(_coverage_fout);
    }
    if (attrp->parent) {
      {
      fprintf(_coverage_fout, "2261\n");
      fflush(_coverage_fout);
      }
      tmp___1 = php_dom_create_object(attrp->parent, & ret, rv, return_value,
                                      intern);
      {
      fprintf(_coverage_fout, "2262\n");
      fflush(_coverage_fout);
      }
      rv = (zval *)tmp___1;
      {
      fprintf(_coverage_fout, "2263\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )((void *)0) == (unsigned int )rv) {
        {
        fprintf(_coverage_fout, "2257\n");
        fflush(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Cannot create required DOM object");
        {
        fprintf(_coverage_fout, "2258\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "2254\n");
          fflush(_coverage_fout);
          }
          __z = return_value;
          {
          fprintf(_coverage_fout, "2255\n");
          fflush(_coverage_fout);
          }
          __z->value.lval = 0L;
          {
          fprintf(_coverage_fout, "2256\n");
          fflush(_coverage_fout);
          }
          __z->type = (unsigned char)3;
          break;
        }
        {
        fprintf(_coverage_fout, "2259\n");
        fflush(_coverage_fout);
        }
        return;
      } else {
        {
        fprintf(_coverage_fout, "2260\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2264\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
    }
  } else {
    {
    fprintf(_coverage_fout, "2266\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
  }
  {
  fprintf(_coverage_fout, "2275\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_get_element_by_id(int ht , zval *return_value ,
                                        zval **return_value_ptr ,
                                        zval *this_ptr , int return_value_used ) ;
extern void dom_namednode_iter(dom_object *basenode , int ntype ,
                               dom_object *intern , xmlHashTablePtr ht ,
                               xmlChar *local , xmlChar *ns ) ;
extern xmlChar *xmlCharStrndup(char const   *cur , int len ) ;
struct _zend_object;
extern zend_object __attribute__((__visibility__("default")))  *zend_objects_get_address(zval const   *object ) ;
extern void php_dom_create_interator(zval *return_value , int ce_type ) ;
void zif_dom_document_get_elements_by_tag_name_ns(int ht , zval *return_value ,
                                                  zval **return_value_ptr ,
                                                  zval *this_ptr ,
                                                  int return_value_used ) 
{ zval *id ;
  xmlDocPtr docp ;
  int uri_len ;
  int name_len ;
  dom_object *intern ;
  dom_object *namednode ;
  char *uri ;
  char *name ;
  xmlChar *local ;
  xmlChar *nsuri ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_object __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2231\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Oss", & id,
                                     dom_document_class_entry, & uri, & uri_len,
                                     & name, & name_len);
  {
  fprintf(_coverage_fout, "2232\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2220\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2221\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2233\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2234\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2235\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2222\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2223\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2224\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2229\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2230\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2225\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2226\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2227\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2228\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2236\n");
  fflush(_coverage_fout);
  }
  php_dom_create_interator(return_value, 0);
  {
  fprintf(_coverage_fout, "2237\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_objects_get_address((zval const   *)return_value);
  {
  fprintf(_coverage_fout, "2238\n");
  fflush(_coverage_fout);
  }
  namednode = (dom_object *)tmp___1;
  {
  fprintf(_coverage_fout, "2239\n");
  fflush(_coverage_fout);
  }
  local = xmlCharStrndup((char const   *)name, name_len);
  {
  fprintf(_coverage_fout, "2240\n");
  fflush(_coverage_fout);
  }
  nsuri = xmlCharStrndup((char const   *)uri, uri_len);
  {
  fprintf(_coverage_fout, "2241\n");
  fflush(_coverage_fout);
  }
  dom_namednode_iter(intern, 0, namednode, (xmlHashTable *)((void *)0), local,
                     nsuri);
  {
  fprintf(_coverage_fout, "2242\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_get_elements_by_tag_name_ns(int ht , zval *return_value ,
                                                  zval **return_value_ptr ,
                                                  zval *this_ptr ,
                                                  int return_value_used ) ;
extern void xmlFreeProp(xmlAttrPtr cur ) ;
typedef xmlNs *xmlNsPtr;
extern void xmlSetNs(xmlNodePtr node , xmlNsPtr ns ) ;
extern xmlNsPtr dom_get_ns(xmlNodePtr node , char *uri , int *errorcode ,
                           char *prefix ) ;
extern xmlNsPtr xmlSearchNsByHref(xmlDocPtr doc , xmlNodePtr node ,
                                  xmlChar const   *href ) ;
extern xmlAttrPtr xmlNewDocProp(xmlDocPtr doc , xmlChar const   *name ,
                                xmlChar const   *value ) ;
extern int xmlValidateName(xmlChar const   *value , int space ) ;
extern int dom_check_qname(char *qname , char **localname , char **prefix ,
                           int uri_len , int name_len ) ;
extern xmlNodePtr xmlDocGetRootElement(xmlDocPtr doc ) ;
void zif_dom_document_create_attribute_ns(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlDocPtr docp ;
  xmlNodePtr nodep ;
  xmlNodePtr root ;
  xmlNsPtr nsptr ;
  int ret ;
  int uri_len ;
  int name_len ;
  char *uri ;
  char *name ;
  char *localname ;
  char *prefix ;
  dom_object *intern ;
  int errorcode ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  xmlAttrPtr tmp___1 ;
  int tmp___2 ;
  zval *__z ;
  int tmp___3 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval *__z___2 ;
  zval __attribute__((__visibility__("default")))  *tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2199\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "2200\n");
  fflush(_coverage_fout);
  }
  nodep = (xmlNodePtr )((void *)0);
  {
  fprintf(_coverage_fout, "2201\n");
  fflush(_coverage_fout);
  }
  uri_len = 0;
  {
  fprintf(_coverage_fout, "2202\n");
  fflush(_coverage_fout);
  }
  name_len = 0;
  {
  fprintf(_coverage_fout, "2203\n");
  fflush(_coverage_fout);
  }
  localname = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2204\n");
  fflush(_coverage_fout);
  }
  prefix = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2205\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os!s", & id,
                                     dom_document_class_entry, & uri, & uri_len,
                                     & name, & name_len);
  {
  fprintf(_coverage_fout, "2206\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2139\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2140\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2207\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2208\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2209\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2141\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2142\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2143\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2148\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2149\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2144\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2145\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2146\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2147\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2210\n");
  fflush(_coverage_fout);
  }
  root = xmlDocGetRootElement(docp);
  {
  fprintf(_coverage_fout, "2211\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )root != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2165\n");
    fflush(_coverage_fout);
    }
    errorcode = dom_check_qname(name, & localname, & prefix, uri_len, name_len);
    {
    fprintf(_coverage_fout, "2166\n");
    fflush(_coverage_fout);
    }
    if (errorcode == 0) {
      {
      fprintf(_coverage_fout, "2162\n");
      fflush(_coverage_fout);
      }
      tmp___2 = xmlValidateName((xmlChar const   *)((xmlChar *)localname), 0);
      {
      fprintf(_coverage_fout, "2163\n");
      fflush(_coverage_fout);
      }
      if (tmp___2 == 0) {
        {
        fprintf(_coverage_fout, "2158\n");
        fflush(_coverage_fout);
        }
        tmp___1 = xmlNewDocProp(docp, (xmlChar const   *)localname,
                                (xmlChar const   *)((void *)0));
        {
        fprintf(_coverage_fout, "2159\n");
        fflush(_coverage_fout);
        }
        nodep = (xmlNode *)tmp___1;
        {
        fprintf(_coverage_fout, "2160\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )nodep != (unsigned int )((void *)0)) {
          {
          fprintf(_coverage_fout, "2156\n");
          fflush(_coverage_fout);
          }
          if (uri_len > 0) {
            {
            fprintf(_coverage_fout, "2152\n");
            fflush(_coverage_fout);
            }
            nsptr = xmlSearchNsByHref(nodep->doc, root, (xmlChar const   *)uri);
            {
            fprintf(_coverage_fout, "2153\n");
            fflush(_coverage_fout);
            }
            if ((unsigned int )nsptr == (unsigned int )((void *)0)) {
              {
              fprintf(_coverage_fout, "2150\n");
              fflush(_coverage_fout);
              }
              nsptr = dom_get_ns(root, uri, & errorcode, prefix);
            } else {
              {
              fprintf(_coverage_fout, "2151\n");
              fflush(_coverage_fout);
              }

            }
            {
            fprintf(_coverage_fout, "2154\n");
            fflush(_coverage_fout);
            }
            xmlSetNs(nodep, nsptr);
          } else {
            {
            fprintf(_coverage_fout, "2155\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "2157\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "2161\n");
        fflush(_coverage_fout);
        }
        errorcode = 5;
      }
    } else {
      {
      fprintf(_coverage_fout, "2164\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "2170\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Document Missing Root Element");
    {
    fprintf(_coverage_fout, "2171\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2167\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2168\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2169\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2172\n");
    fflush(_coverage_fout);
    }
    return;
  }
  {
  fprintf(_coverage_fout, "2212\n");
  fflush(_coverage_fout);
  }
  (*xmlFree)((void *)localname);
  {
  fprintf(_coverage_fout, "2213\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )prefix != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2173\n");
    fflush(_coverage_fout);
    }
    (*xmlFree)((void *)prefix);
  } else {
    {
    fprintf(_coverage_fout, "2174\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2214\n");
  fflush(_coverage_fout);
  }
  if (errorcode != 0) {
    {
    fprintf(_coverage_fout, "2180\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )nodep != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "2175\n");
      fflush(_coverage_fout);
      }
      xmlFreeProp((xmlAttr *)nodep);
    } else {
      {
      fprintf(_coverage_fout, "2176\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2181\n");
    fflush(_coverage_fout);
    }
    tmp___3 = dom_get_strict_error(intern->document);
    {
    fprintf(_coverage_fout, "2182\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(errorcode, tmp___3);
    {
    fprintf(_coverage_fout, "2183\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2177\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2178\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2179\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2184\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2185\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2215\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodep == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2189\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2186\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "2187\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2188\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2190\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2191\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2216\n");
  fflush(_coverage_fout);
  }
  tmp___4 = php_dom_create_object(nodep, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "2217\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___4;
  {
  fprintf(_coverage_fout, "2218\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "2195\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "2196\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2192\n");
      fflush(_coverage_fout);
      }
      __z___2 = return_value;
      {
      fprintf(_coverage_fout, "2193\n");
      fflush(_coverage_fout);
      }
      __z___2->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2194\n");
      fflush(_coverage_fout);
      }
      __z___2->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2197\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2198\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2219\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_attribute_ns(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern void xmlFreeNode(xmlNodePtr cur ) ;
extern xmlNodePtr xmlNewDocNode(xmlDocPtr doc , xmlNsPtr ns ,
                                xmlChar const   *name ,
                                xmlChar const   *content ) ;
void zif_dom_document_create_element_ns(int ht , zval *return_value ,
                                        zval **return_value_ptr ,
                                        zval *this_ptr , int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlDocPtr docp ;
  xmlNodePtr nodep ;
  xmlNsPtr nsptr ;
  int ret ;
  int uri_len ;
  int name_len ;
  int value_len ;
  char *uri ;
  char *name ;
  char *value ;
  char *localname ;
  char *prefix ;
  int errorcode ;
  dom_object *intern ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  zval *__z ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2114\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "2115\n");
  fflush(_coverage_fout);
  }
  nodep = (xmlNodePtr )((void *)0);
  {
  fprintf(_coverage_fout, "2116\n");
  fflush(_coverage_fout);
  }
  nsptr = (xmlNsPtr )((void *)0);
  {
  fprintf(_coverage_fout, "2117\n");
  fflush(_coverage_fout);
  }
  uri_len = 0;
  {
  fprintf(_coverage_fout, "2118\n");
  fflush(_coverage_fout);
  }
  name_len = 0;
  {
  fprintf(_coverage_fout, "2119\n");
  fflush(_coverage_fout);
  }
  value_len = 0;
  {
  fprintf(_coverage_fout, "2120\n");
  fflush(_coverage_fout);
  }
  value = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2121\n");
  fflush(_coverage_fout);
  }
  localname = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2122\n");
  fflush(_coverage_fout);
  }
  prefix = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "2123\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os!s|s", & id,
                                     dom_document_class_entry, & uri, & uri_len,
                                     & name, & name_len, & value, & value_len);
  {
  fprintf(_coverage_fout, "2124\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "2063\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2064\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2125\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2126\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2127\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2065\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "2066\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "2067\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2072\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "2073\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "2068\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2069\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "2070\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2071\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2128\n");
  fflush(_coverage_fout);
  }
  errorcode = dom_check_qname(name, & localname, & prefix, uri_len, name_len);
  {
  fprintf(_coverage_fout, "2129\n");
  fflush(_coverage_fout);
  }
  if (errorcode == 0) {
    {
    fprintf(_coverage_fout, "2085\n");
    fflush(_coverage_fout);
    }
    tmp___1 = xmlValidateName((xmlChar const   *)((xmlChar *)localname), 0);
    {
    fprintf(_coverage_fout, "2086\n");
    fflush(_coverage_fout);
    }
    if (tmp___1 == 0) {
      {
      fprintf(_coverage_fout, "2082\n");
      fflush(_coverage_fout);
      }
      nodep = xmlNewDocNode(docp, (xmlNs *)((void *)0),
                            (xmlChar const   *)localname,
                            (xmlChar const   *)value);
      {
      fprintf(_coverage_fout, "2083\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )nodep != (unsigned int )((void *)0)) {
        {
        fprintf(_coverage_fout, "2080\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )uri != (unsigned int )((void *)0)) {
          {
          fprintf(_coverage_fout, "2076\n");
          fflush(_coverage_fout);
          }
          nsptr = xmlSearchNsByHref(nodep->doc, nodep, (xmlChar const   *)uri);
          {
          fprintf(_coverage_fout, "2077\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )nsptr == (unsigned int )((void *)0)) {
            {
            fprintf(_coverage_fout, "2074\n");
            fflush(_coverage_fout);
            }
            nsptr = dom_get_ns(nodep, uri, & errorcode, prefix);
          } else {
            {
            fprintf(_coverage_fout, "2075\n");
            fflush(_coverage_fout);
            }

          }
          {
          fprintf(_coverage_fout, "2078\n");
          fflush(_coverage_fout);
          }
          xmlSetNs(nodep, nsptr);
        } else {
          {
          fprintf(_coverage_fout, "2079\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "2081\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2084\n");
      fflush(_coverage_fout);
      }
      errorcode = 5;
    }
  } else {
    {
    fprintf(_coverage_fout, "2087\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2130\n");
  fflush(_coverage_fout);
  }
  (*xmlFree)((void *)localname);
  {
  fprintf(_coverage_fout, "2131\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )prefix != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2088\n");
    fflush(_coverage_fout);
    }
    (*xmlFree)((void *)prefix);
  } else {
    {
    fprintf(_coverage_fout, "2089\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2132\n");
  fflush(_coverage_fout);
  }
  if (errorcode != 0) {
    {
    fprintf(_coverage_fout, "2095\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )nodep != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "2090\n");
      fflush(_coverage_fout);
      }
      xmlFreeNode(nodep);
    } else {
      {
      fprintf(_coverage_fout, "2091\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2096\n");
    fflush(_coverage_fout);
    }
    tmp___2 = dom_get_strict_error(intern->document);
    {
    fprintf(_coverage_fout, "2097\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(errorcode, tmp___2);
    {
    fprintf(_coverage_fout, "2098\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2092\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "2093\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2094\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2099\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2100\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2133\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodep == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "2104\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2101\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "2102\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2103\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2105\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2106\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2134\n");
  fflush(_coverage_fout);
  }
  nodep->ns = nsptr;
  {
  fprintf(_coverage_fout, "2135\n");
  fflush(_coverage_fout);
  }
  tmp___3 = php_dom_create_object(nodep, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "2136\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___3;
  {
  fprintf(_coverage_fout, "2137\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "2110\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "2111\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2107\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "2108\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2109\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2112\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2113\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2138\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_element_ns(int ht , zval *return_value ,
                                        zval **return_value_ptr ,
                                        zval *this_ptr , int return_value_used ) ;
typedef xmlElementType xmlNsType;
struct _xmlNs {
   struct _xmlNs *next ;
   xmlNsType type ;
   xmlChar const   *href ;
   xmlChar const   *prefix ;
   void *_private ;
   struct _xmlDoc *context ;
};
extern xmlNodePtr xmlDocCopyNode(xmlNodePtr node , xmlDocPtr doc ,
                                 int recursive ) ;
void zif_dom_document_import_node(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) 
{ zval *rv ;
  zval *id ;
  zval *node ;
  xmlDocPtr docp ;
  xmlNodePtr nodep ;
  xmlNodePtr retnodep ;
  dom_object *intern ;
  dom_object *nodeobj ;
  int ret ;
  long recursive ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z ;
  zval *__z___0 ;
  xmlNsPtr nsptr ;
  xmlNodePtr root ;
  xmlNodePtr tmp___2 ;
  int errorcode ;
  zval *__z___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "2047\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "2048\n");
  fflush(_coverage_fout);
  }
  recursive = 0L;
  {
  fprintf(_coverage_fout, "2049\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "OO|l", & id,
                                     dom_document_class_entry, & node,
                                     dom_node_class_entry, & recursive);
  {
  fprintf(_coverage_fout, "2050\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1985\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1986\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2051\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "2052\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "2053\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1987\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1988\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1989\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1994\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1995\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1990\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1991\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1992\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1993\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2054\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)node);
  {
  fprintf(_coverage_fout, "2055\n");
  fflush(_coverage_fout);
  }
  nodeobj = (dom_object *)tmp___1;
  {
  fprintf(_coverage_fout, "2056\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodeobj->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1996\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (nodeobj->std.ce)->name);
    {
    fprintf(_coverage_fout, "1997\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1998\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2003\n");
    fflush(_coverage_fout);
    }
    nodep = ((php_libxml_node_ptr *)nodeobj->ptr)->node;
    {
    fprintf(_coverage_fout, "2004\n");
    fflush(_coverage_fout);
    }
    if (nodep) {
      {
      fprintf(_coverage_fout, "1999\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "2000\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (nodeobj->std.ce)->name);
      {
      fprintf(_coverage_fout, "2001\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "2002\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "2057\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodep->type == 13U) {
    goto _L;
  } else {
    {
    fprintf(_coverage_fout, "2013\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )nodep->type == 9U) {
      goto _L;
    } else {
      {
      fprintf(_coverage_fout, "2012\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )nodep->type == 10U) {
        {
        fprintf(_coverage_fout, "2008\n");
        fflush(_coverage_fout);
        }
        _L: /* CIL Label */ 
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Cannot import: Node Type Not Supported");
        {
        fprintf(_coverage_fout, "2009\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "2005\n");
          fflush(_coverage_fout);
          }
          __z = return_value;
          {
          fprintf(_coverage_fout, "2006\n");
          fflush(_coverage_fout);
          }
          __z->value.lval = 0L;
          {
          fprintf(_coverage_fout, "2007\n");
          fflush(_coverage_fout);
          }
          __z->type = (unsigned char)3;
          break;
        }
        {
        fprintf(_coverage_fout, "2010\n");
        fflush(_coverage_fout);
        }
        return;
      } else {
        {
        fprintf(_coverage_fout, "2011\n");
        fflush(_coverage_fout);
        }

      }
    }
  }
  {
  fprintf(_coverage_fout, "2058\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )nodep->doc == (unsigned int )docp) {
    {
    fprintf(_coverage_fout, "2014\n");
    fflush(_coverage_fout);
    }
    retnodep = nodep;
  } else {
    {
    fprintf(_coverage_fout, "2036\n");
    fflush(_coverage_fout);
    }
    if (recursive == 0L) {
      {
      fprintf(_coverage_fout, "2017\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )nodep->type == 1U) {
        {
        fprintf(_coverage_fout, "2015\n");
        fflush(_coverage_fout);
        }
        recursive = 2L;
      } else {
        {
        fprintf(_coverage_fout, "2016\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2018\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2037\n");
    fflush(_coverage_fout);
    }
    retnodep = xmlDocCopyNode(nodep, docp, (int )recursive);
    {
    fprintf(_coverage_fout, "2038\n");
    fflush(_coverage_fout);
    }
    if (! retnodep) {
      {
      fprintf(_coverage_fout, "2022\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "2019\n");
        fflush(_coverage_fout);
        }
        __z___0 = return_value;
        {
        fprintf(_coverage_fout, "2020\n");
        fflush(_coverage_fout);
        }
        __z___0->value.lval = 0L;
        {
        fprintf(_coverage_fout, "2021\n");
        fflush(_coverage_fout);
        }
        __z___0->type = (unsigned char)3;
        break;
      }
      {
      fprintf(_coverage_fout, "2023\n");
      fflush(_coverage_fout);
      }
      return;
    } else {
      {
      fprintf(_coverage_fout, "2024\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "2039\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )retnodep->type == 2U) {
      {
      fprintf(_coverage_fout, "2034\n");
      fflush(_coverage_fout);
      }
      if ((unsigned int )nodep->ns != (unsigned int )((void *)0)) {
        {
        fprintf(_coverage_fout, "2027\n");
        fflush(_coverage_fout);
        }
        nsptr = (xmlNsPtr )((void *)0);
        {
        fprintf(_coverage_fout, "2028\n");
        fflush(_coverage_fout);
        }
        tmp___2 = xmlDocGetRootElement(docp);
        {
        fprintf(_coverage_fout, "2029\n");
        fflush(_coverage_fout);
        }
        root = tmp___2;
        {
        fprintf(_coverage_fout, "2030\n");
        fflush(_coverage_fout);
        }
        nsptr = xmlSearchNsByHref(nodep->doc, root, (nodep->ns)->href);
        {
        fprintf(_coverage_fout, "2031\n");
        fflush(_coverage_fout);
        }
        if ((unsigned int )nsptr == (unsigned int )((void *)0)) {
          {
          fprintf(_coverage_fout, "2025\n");
          fflush(_coverage_fout);
          }
          nsptr = dom_get_ns(root, (char *)(nodep->ns)->href, & errorcode,
                             (char *)(nodep->ns)->prefix);
        } else {
          {
          fprintf(_coverage_fout, "2026\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "2032\n");
        fflush(_coverage_fout);
        }
        xmlSetNs(retnodep, nsptr);
      } else {
        {
        fprintf(_coverage_fout, "2033\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "2035\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "2059\n");
  fflush(_coverage_fout);
  }
  tmp___3 = php_dom_create_object(retnodep, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "2060\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___3;
  {
  fprintf(_coverage_fout, "2061\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "2043\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "2044\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "2040\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "2041\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "2042\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "2045\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "2046\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "2062\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_import_node(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
void zif_dom_document_get_elements_by_tag_name(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) 
{ zval *id ;
  xmlDocPtr docp ;
  int name_len ;
  dom_object *intern ;
  dom_object *namednode ;
  char *name ;
  xmlChar *local ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_object __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1974\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & name,
                                     & name_len);
  {
  fprintf(_coverage_fout, "1975\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1963\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1964\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1976\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1977\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1978\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1965\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1966\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1967\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1972\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1973\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1968\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1969\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1970\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1971\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1979\n");
  fflush(_coverage_fout);
  }
  php_dom_create_interator(return_value, 0);
  {
  fprintf(_coverage_fout, "1980\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_objects_get_address((zval const   *)return_value);
  {
  fprintf(_coverage_fout, "1981\n");
  fflush(_coverage_fout);
  }
  namednode = (dom_object *)tmp___1;
  {
  fprintf(_coverage_fout, "1982\n");
  fflush(_coverage_fout);
  }
  local = xmlCharStrndup((char const   *)name, name_len);
  {
  fprintf(_coverage_fout, "1983\n");
  fflush(_coverage_fout);
  }
  dom_namednode_iter(intern, 0, namednode, (xmlHashTable *)((void *)0), local,
                     (xmlChar *)((void *)0));
  {
  fprintf(_coverage_fout, "1984\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_get_elements_by_tag_name(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern xmlNodePtr xmlNewReference(xmlDocPtr doc , xmlChar const   *name ) ;
void zif_dom_document_create_entity_reference(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  dom_object *intern ;
  int ret ;
  int name_len ;
  char *name ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int tmp___1 ;
  zval *__z ;
  int tmp___2 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1948\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1949\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDocPtr )((void *)0);
  {
  fprintf(_coverage_fout, "1950\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & name,
                                     & name_len);
  {
  fprintf(_coverage_fout, "1951\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1916\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1917\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1952\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1953\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1954\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1918\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1919\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1920\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1925\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1926\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1921\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1922\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1923\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1924\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1955\n");
  fflush(_coverage_fout);
  }
  tmp___2 = xmlValidateName((xmlChar const   *)((xmlChar *)name), 0);
  {
  fprintf(_coverage_fout, "1956\n");
  fflush(_coverage_fout);
  }
  if (tmp___2 != 0) {
    {
    fprintf(_coverage_fout, "1930\n");
    fflush(_coverage_fout);
    }
    tmp___1 = dom_get_strict_error(intern->document);
    {
    fprintf(_coverage_fout, "1931\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(5, tmp___1);
    {
    fprintf(_coverage_fout, "1932\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1927\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1928\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1929\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1933\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1934\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1957\n");
  fflush(_coverage_fout);
  }
  node = xmlNewReference(docp, (xmlChar const   *)name);
  {
  fprintf(_coverage_fout, "1958\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1938\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1935\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1936\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1937\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1939\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1940\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1959\n");
  fflush(_coverage_fout);
  }
  tmp___3 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1960\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___3;
  {
  fprintf(_coverage_fout, "1961\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1944\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1945\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1941\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "1942\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1943\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1946\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1947\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1962\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_entity_reference(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
void zif_dom_document_create_attribute(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlAttrPtr node ;
  xmlDocPtr docp ;
  int ret ;
  int name_len ;
  dom_object *intern ;
  char *name ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int tmp___1 ;
  zval *__z ;
  int tmp___2 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1902\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1903\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & name,
                                     & name_len);
  {
  fprintf(_coverage_fout, "1904\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1870\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1871\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1905\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1906\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1907\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1872\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1873\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1874\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1879\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1880\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1875\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1876\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1877\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1878\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1908\n");
  fflush(_coverage_fout);
  }
  tmp___2 = xmlValidateName((xmlChar const   *)((xmlChar *)name), 0);
  {
  fprintf(_coverage_fout, "1909\n");
  fflush(_coverage_fout);
  }
  if (tmp___2 != 0) {
    {
    fprintf(_coverage_fout, "1884\n");
    fflush(_coverage_fout);
    }
    tmp___1 = dom_get_strict_error(intern->document);
    {
    fprintf(_coverage_fout, "1885\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(5, tmp___1);
    {
    fprintf(_coverage_fout, "1886\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1881\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1882\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1883\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1887\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1888\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1910\n");
  fflush(_coverage_fout);
  }
  node = xmlNewDocProp(docp, (xmlChar const   *)((xmlChar *)name),
                       (xmlChar const   *)((void *)0));
  {
  fprintf(_coverage_fout, "1911\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1892\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1889\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1890\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1891\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1893\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1894\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1912\n");
  fflush(_coverage_fout);
  }
  tmp___3 = php_dom_create_object((xmlNode *)node, & ret, rv, return_value,
                                  intern);
  {
  fprintf(_coverage_fout, "1913\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___3;
  {
  fprintf(_coverage_fout, "1914\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1898\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1899\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1895\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "1896\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1897\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1900\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1901\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1915\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_attribute(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern xmlNodePtr xmlNewPI(xmlChar const   *name , xmlChar const   *content ) ;
void zif_dom_document_create_processing_instruction(int ht ,
                                                    zval *return_value ,
                                                    zval **return_value_ptr ,
                                                    zval *this_ptr ,
                                                    int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  int ret ;
  int value_len ;
  int name_len ;
  dom_object *intern ;
  char *name ;
  char *value ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int tmp___1 ;
  zval *__z ;
  int tmp___2 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1853\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1854\n");
  fflush(_coverage_fout);
  }
  name_len = 0;
  {
  fprintf(_coverage_fout, "1855\n");
  fflush(_coverage_fout);
  }
  value = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "1856\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os|s", & id,
                                     dom_document_class_entry, & name,
                                     & name_len, & value, & value_len);
  {
  fprintf(_coverage_fout, "1857\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1821\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1822\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1858\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1859\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1860\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1823\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1824\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1825\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1830\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1831\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1826\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1827\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1828\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1829\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1861\n");
  fflush(_coverage_fout);
  }
  tmp___2 = xmlValidateName((xmlChar const   *)((xmlChar *)name), 0);
  {
  fprintf(_coverage_fout, "1862\n");
  fflush(_coverage_fout);
  }
  if (tmp___2 != 0) {
    {
    fprintf(_coverage_fout, "1835\n");
    fflush(_coverage_fout);
    }
    tmp___1 = dom_get_strict_error(intern->document);
    {
    fprintf(_coverage_fout, "1836\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(5, tmp___1);
    {
    fprintf(_coverage_fout, "1837\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1832\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1833\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1834\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1838\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1839\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1863\n");
  fflush(_coverage_fout);
  }
  node = xmlNewPI((xmlChar const   *)((xmlChar *)name),
                  (xmlChar const   *)((xmlChar *)value));
  {
  fprintf(_coverage_fout, "1864\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1843\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1840\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1841\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1842\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1844\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1845\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1865\n");
  fflush(_coverage_fout);
  }
  node->doc = docp;
  {
  fprintf(_coverage_fout, "1866\n");
  fflush(_coverage_fout);
  }
  tmp___3 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1867\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___3;
  {
  fprintf(_coverage_fout, "1868\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1849\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1850\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1846\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "1847\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1848\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1851\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1852\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1869\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_processing_instruction(int ht ,
                                                    zval *return_value ,
                                                    zval **return_value_ptr ,
                                                    zval *this_ptr ,
                                                    int return_value_used ) ;
extern xmlNodePtr xmlNewCDataBlock(xmlDocPtr doc , xmlChar const   *content ,
                                   int len ) ;
void zif_dom_document_create_cdatasection(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  int ret ;
  int value_len ;
  dom_object *intern ;
  char *value ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval *__z___0 ;
  zval __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1809\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1810\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & value,
                                     & value_len);
  {
  fprintf(_coverage_fout, "1811\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1785\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1786\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1812\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1813\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1814\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1787\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1788\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1789\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1794\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1795\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1790\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1791\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1792\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1793\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1815\n");
  fflush(_coverage_fout);
  }
  node = xmlNewCDataBlock(docp, (xmlChar const   *)((xmlChar *)value), value_len);
  {
  fprintf(_coverage_fout, "1816\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1799\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1796\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1797\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1798\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1800\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1801\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1817\n");
  fflush(_coverage_fout);
  }
  tmp___1 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1818\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___1;
  {
  fprintf(_coverage_fout, "1819\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1805\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1806\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1802\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1803\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1804\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1807\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1808\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1820\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_cdatasection(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern xmlNodePtr xmlNewDocComment(xmlDocPtr doc , xmlChar const   *content ) ;
void zif_dom_document_create_comment(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  int ret ;
  int value_len ;
  dom_object *intern ;
  char *value ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval *__z___0 ;
  zval __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1773\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1774\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & value,
                                     & value_len);
  {
  fprintf(_coverage_fout, "1775\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1749\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1750\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1776\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1777\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1778\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1751\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1752\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1753\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1758\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1759\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1754\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1755\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1756\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1757\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1779\n");
  fflush(_coverage_fout);
  }
  node = xmlNewDocComment(docp, (xmlChar const   *)((xmlChar *)value));
  {
  fprintf(_coverage_fout, "1780\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1763\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1760\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1761\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1762\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1764\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1765\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1781\n");
  fflush(_coverage_fout);
  }
  tmp___1 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1782\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___1;
  {
  fprintf(_coverage_fout, "1783\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1769\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1770\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1766\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1767\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1768\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1771\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1772\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1784\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_comment(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern xmlNodePtr xmlNewDocText(xmlDocPtr doc , xmlChar const   *content ) ;
void zif_dom_document_create_text_node(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  int ret ;
  int value_len ;
  dom_object *intern ;
  char *value ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval *__z___0 ;
  zval __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1737\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1738\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & id,
                                     dom_document_class_entry, & value,
                                     & value_len);
  {
  fprintf(_coverage_fout, "1739\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1713\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1714\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1740\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1741\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1742\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1715\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1716\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1717\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1722\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1723\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1718\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1719\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1720\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1721\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1743\n");
  fflush(_coverage_fout);
  }
  node = xmlNewDocText(docp, (xmlChar const   *)((xmlChar *)value));
  {
  fprintf(_coverage_fout, "1744\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1727\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1724\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1725\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1726\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1728\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1729\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1745\n");
  fflush(_coverage_fout);
  }
  tmp___1 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1746\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___1;
  {
  fprintf(_coverage_fout, "1747\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1733\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1734\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1730\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1731\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1732\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1735\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1736\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1748\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_text_node(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern xmlNodePtr xmlNewDocFragment(xmlDocPtr doc ) ;
void zif_dom_document_create_document_fragment(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  dom_object *intern ;
  int ret ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  zval *__z___0 ;
  zval __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1701\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1702\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & id,
                                     dom_document_class_entry);
  {
  fprintf(_coverage_fout, "1703\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1677\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1678\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1704\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1705\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1706\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1679\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1680\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1681\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1686\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1687\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1682\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1683\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1684\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1685\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1707\n");
  fflush(_coverage_fout);
  }
  node = xmlNewDocFragment(docp);
  {
  fprintf(_coverage_fout, "1708\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1691\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1688\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1689\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1690\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1692\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1693\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1709\n");
  fflush(_coverage_fout);
  }
  tmp___1 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1710\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___1;
  {
  fprintf(_coverage_fout, "1711\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1697\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1698\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1694\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1695\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1696\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1699\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1700\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1712\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_document_fragment(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
void zif_dom_document_create_element(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) 
{ zval *id ;
  zval *rv ;
  xmlNode *node ;
  xmlDocPtr docp ;
  dom_object *intern ;
  int ret ;
  int name_len ;
  int value_len ;
  char *name ;
  char *value ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int tmp___1 ;
  zval *__z ;
  int tmp___2 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1662\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  fprintf(_coverage_fout, "1663\n");
  fflush(_coverage_fout);
  }
  value = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "1664\n");
  fflush(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os|s", & id,
                                     dom_document_class_entry, & name,
                                     & name_len, & value, & value_len);
  {
  fprintf(_coverage_fout, "1665\n");
  fflush(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    fprintf(_coverage_fout, "1630\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1631\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1666\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)id);
  {
  fprintf(_coverage_fout, "1667\n");
  fflush(_coverage_fout);
  }
  intern = (dom_object *)tmp___0;
  {
  fprintf(_coverage_fout, "1668\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )intern->ptr == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1632\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Couldn\'t fetch %s", (intern->std.ce)->name);
    {
    fprintf(_coverage_fout, "1633\n");
    fflush(_coverage_fout);
    }
    return_value->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1634\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1639\n");
    fflush(_coverage_fout);
    }
    docp = (xmlDoc *)((php_libxml_node_ptr *)intern->ptr)->node;
    {
    fprintf(_coverage_fout, "1640\n");
    fflush(_coverage_fout);
    }
    if (docp) {
      {
      fprintf(_coverage_fout, "1635\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "1636\n");
      fflush(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Couldn\'t fetch %s", (intern->std.ce)->name);
      {
      fprintf(_coverage_fout, "1637\n");
      fflush(_coverage_fout);
      }
      return_value->type = (unsigned char)0;
      {
      fprintf(_coverage_fout, "1638\n");
      fflush(_coverage_fout);
      }
      return;
    }
  }
  {
  fprintf(_coverage_fout, "1669\n");
  fflush(_coverage_fout);
  }
  tmp___2 = xmlValidateName((xmlChar const   *)((xmlChar *)name), 0);
  {
  fprintf(_coverage_fout, "1670\n");
  fflush(_coverage_fout);
  }
  if (tmp___2 != 0) {
    {
    fprintf(_coverage_fout, "1644\n");
    fflush(_coverage_fout);
    }
    tmp___1 = dom_get_strict_error(intern->document);
    {
    fprintf(_coverage_fout, "1645\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(5, tmp___1);
    {
    fprintf(_coverage_fout, "1646\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1641\n");
      fflush(_coverage_fout);
      }
      __z = return_value;
      {
      fprintf(_coverage_fout, "1642\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1643\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1647\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1648\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1671\n");
  fflush(_coverage_fout);
  }
  node = xmlNewDocNode(docp, (xmlNs *)((void *)0), (xmlChar const   *)name,
                       (xmlChar const   *)value);
  {
  fprintf(_coverage_fout, "1672\n");
  fflush(_coverage_fout);
  }
  if (! node) {
    {
    fprintf(_coverage_fout, "1652\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1649\n");
      fflush(_coverage_fout);
      }
      __z___0 = return_value;
      {
      fprintf(_coverage_fout, "1650\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1651\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1653\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1654\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1673\n");
  fflush(_coverage_fout);
  }
  tmp___3 = php_dom_create_object(node, & ret, rv, return_value, intern);
  {
  fprintf(_coverage_fout, "1674\n");
  fflush(_coverage_fout);
  }
  rv = (zval *)tmp___3;
  {
  fprintf(_coverage_fout, "1675\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )rv) {
    {
    fprintf(_coverage_fout, "1658\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1659\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1655\n");
      fflush(_coverage_fout);
      }
      __z___1 = return_value;
      {
      fprintf(_coverage_fout, "1656\n");
      fflush(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1657\n");
      fflush(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    fprintf(_coverage_fout, "1660\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "1661\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1676\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void zif_dom_document_create_element(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
struct _gc_root_buffer;
typedef struct _gc_root_buffer gc_root_buffer;
struct _zval_gc_info;
typedef struct _zval_gc_info zval_gc_info;
union __anonunion_u_46 {
   gc_root_buffer *buffered ;
   struct _zval_gc_info *next ;
};
struct _zval_gc_info {
   zval z ;
   union __anonunion_u_46 u ;
};
extern void __attribute__((__visibility__("default")))  *_emalloc(size_t size )  __attribute__((__malloc__)) ;
int dom_document_config_read(dom_object *obj , zval **retval ) 
{ void __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1627\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1624\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1625\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1626\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1628\n");
  fflush(_coverage_fout);
  }
  (*retval)->type = (unsigned char)0;
  {
  fprintf(_coverage_fout, "1629\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_config_read(dom_object *obj , zval **retval ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_dtor)(zval *zvalue ) ;
extern void __attribute__((__visibility__("default")))  _convert_to_string(zval *op ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_copy_ctor)(zval *zvalue ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_refcount_p)(zval *pz ) ;
int dom_document_document_uri_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  xmlDoc *docp ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  zend_uint tmp___0 ;
  xmlChar *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1615\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1616\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1617\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1598\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1599\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1600\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1618\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp->URL != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1601\n");
    fflush(_coverage_fout);
    }
    (*xmlFree)((void *)((xmlChar *)docp->URL));
  } else {
    {
    fprintf(_coverage_fout, "1602\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1619\n");
  fflush(_coverage_fout);
  }
  if ((int )newval->type != 6) {
    {
    fprintf(_coverage_fout, "1609\n");
    fflush(_coverage_fout);
    }
    tmp___0 = zval_refcount_p(newval);
    {
    fprintf(_coverage_fout, "1610\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 1U) {
      {
      fprintf(_coverage_fout, "1603\n");
      fflush(_coverage_fout);
      }
      value_copy = *newval;
      {
      fprintf(_coverage_fout, "1604\n");
      fflush(_coverage_fout);
      }
      _zval_copy_ctor(& value_copy);
      {
      fprintf(_coverage_fout, "1605\n");
      fflush(_coverage_fout);
      }
      newval = & value_copy;
    } else {
      {
      fprintf(_coverage_fout, "1606\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "1611\n");
    fflush(_coverage_fout);
    }
    if ((int )newval->type != 6) {
      {
      fprintf(_coverage_fout, "1607\n");
      fflush(_coverage_fout);
      }
      _convert_to_string(newval);
    } else {
      {
      fprintf(_coverage_fout, "1608\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "1612\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1620\n");
  fflush(_coverage_fout);
  }
  tmp___1 = xmlStrdup((xmlChar const   *)newval->value.str.val);
  {
  fprintf(_coverage_fout, "1621\n");
  fflush(_coverage_fout);
  }
  docp->URL = (xmlChar const   *)tmp___1;
  {
  fprintf(_coverage_fout, "1622\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1613\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1614\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1623\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_document_uri_write(dom_object *obj , zval *newval ) ;
int dom_document_document_uri_read(dom_object *obj , zval **retval ) 
{ xmlDoc *docp ;
  char *url ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1591\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1592\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1593\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1576\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1577\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1578\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1594\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1579\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1580\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp___0;
    {
    fprintf(_coverage_fout, "1581\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1595\n");
  fflush(_coverage_fout);
  }
  url = (char *)docp->URL;
  {
  fprintf(_coverage_fout, "1596\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )url != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1589\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1582\n");
      fflush(_coverage_fout);
      }
      __s = (char const   *)url;
      {
      fprintf(_coverage_fout, "1583\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1584\n");
      fflush(_coverage_fout);
      }
      tmp___1 = strlen(__s);
      {
      fprintf(_coverage_fout, "1585\n");
      fflush(_coverage_fout);
      }
      __z->value.str.len = (int )tmp___1;
      {
      fprintf(_coverage_fout, "1586\n");
      fflush(_coverage_fout);
      }
      tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
      {
      fprintf(_coverage_fout, "1587\n");
      fflush(_coverage_fout);
      }
      __z->value.str.val = (char *)tmp___2;
      {
      fprintf(_coverage_fout, "1588\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)6;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1590\n");
    fflush(_coverage_fout);
    }
    (*retval)->type = (unsigned char)0;
  }
  {
  fprintf(_coverage_fout, "1597\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_document_uri_read(dom_object *obj , zval **retval ) ;
extern void __attribute__((__visibility__("default")))  convert_to_boolean(zval *op ) ;
int dom_document_substitue_entities_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1570\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1571\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1561\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1562\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1563\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1564\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1572\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1573\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1565\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1566\n");
    fflush(_coverage_fout);
    }
    doc_prop->substituteentities = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1567\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1574\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1568\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1569\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1575\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_substitue_entities_write(dom_object *obj , zval *newval ) ;
int dom_document_substitue_entities_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1558\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1546\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1547\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1548\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1559\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1552\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1553\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1549\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1550\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->substituteentities != 0);
      {
      fprintf(_coverage_fout, "1551\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1557\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1554\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1555\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1556\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1560\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_substitue_entities_read(dom_object *obj , zval **retval ) ;
int dom_document_recover_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1540\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1541\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1531\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1532\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1533\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1534\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1542\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1543\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1535\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1536\n");
    fflush(_coverage_fout);
    }
    doc_prop->recover = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1537\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1544\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1538\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1539\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1545\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_recover_write(dom_object *obj , zval *newval ) ;
int dom_document_recover_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1528\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1516\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1517\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1518\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1529\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1522\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1523\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1519\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1520\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->recover != 0);
      {
      fprintf(_coverage_fout, "1521\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1527\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1524\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1525\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1526\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1530\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_recover_read(dom_object *obj , zval **retval ) ;
int dom_document_preserve_whitespace_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1510\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1511\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1501\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1502\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1503\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1504\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1512\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1513\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1505\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1506\n");
    fflush(_coverage_fout);
    }
    doc_prop->preservewhitespace = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1507\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1514\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1508\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1509\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1515\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_preserve_whitespace_write(dom_object *obj , zval *newval ) ;
int dom_document_preserve_whitespace_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1498\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1486\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1487\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1488\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1499\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1492\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1493\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1489\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1490\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->preservewhitespace != 0);
      {
      fprintf(_coverage_fout, "1491\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1497\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1494\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1495\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1496\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1500\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_preserve_whitespace_read(dom_object *obj , zval **retval ) ;
int dom_document_resolve_externals_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1480\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1481\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1471\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1472\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1473\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1474\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1482\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1483\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1475\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1476\n");
    fflush(_coverage_fout);
    }
    doc_prop->resolveexternals = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1477\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1484\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1478\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1479\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1485\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_resolve_externals_write(dom_object *obj , zval *newval ) ;
int dom_document_resolve_externals_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1468\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1456\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1457\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1458\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1469\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1462\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1463\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1459\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1460\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->resolveexternals != 0);
      {
      fprintf(_coverage_fout, "1461\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1467\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1464\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1465\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1466\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1470\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_resolve_externals_read(dom_object *obj , zval **retval ) ;
int dom_document_validate_on_parse_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1450\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1451\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1441\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1442\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1443\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1444\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1452\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1453\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1445\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1446\n");
    fflush(_coverage_fout);
    }
    doc_prop->validateonparse = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1447\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1454\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1448\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1449\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1455\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_validate_on_parse_write(dom_object *obj , zval *newval ) ;
int dom_document_validate_on_parse_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1438\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1426\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1427\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1428\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1439\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1432\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1433\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1429\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1430\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->validateonparse != 0);
      {
      fprintf(_coverage_fout, "1431\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1437\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1434\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1435\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1436\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1440\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_validate_on_parse_read(dom_object *obj , zval **retval ) ;
int dom_document_format_output_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1420\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1421\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1411\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1412\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1413\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1414\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1422\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1423\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1415\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1416\n");
    fflush(_coverage_fout);
    }
    doc_prop->formatoutput = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1417\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1424\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1418\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1419\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1425\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_format_output_write(dom_object *obj , zval *newval ) ;
int dom_document_format_output_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1408\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1396\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1397\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1398\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1409\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1402\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1403\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1399\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1400\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->formatoutput != 0);
      {
      fprintf(_coverage_fout, "1401\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1407\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1404\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1405\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1406\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1410\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_format_output_read(dom_object *obj , zval **retval ) ;
int dom_document_strict_error_checking_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  dom_doc_propsptr doc_prop ;
  zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1390\n");
  fflush(_coverage_fout);
  }
  tmp = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1391\n");
  fflush(_coverage_fout);
  }
  if (tmp > 1U) {
    {
    fprintf(_coverage_fout, "1381\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1382\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1383\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1384\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1392\n");
  fflush(_coverage_fout);
  }
  convert_to_boolean(newval);
  {
  fprintf(_coverage_fout, "1393\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1385\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1386\n");
    fflush(_coverage_fout);
    }
    doc_prop->stricterror = (int )newval->value.lval;
  } else {
    {
    fprintf(_coverage_fout, "1387\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1394\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1388\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1389\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1395\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_strict_error_checking_write(dom_object *obj , zval *newval ) ;
int dom_document_strict_error_checking_read(dom_object *obj , zval **retval ) 
{ dom_doc_propsptr doc_prop ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1378\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1366\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1367\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1368\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1379\n");
  fflush(_coverage_fout);
  }
  if (obj->document) {
    {
    fprintf(_coverage_fout, "1372\n");
    fflush(_coverage_fout);
    }
    doc_prop = dom_get_doc_props(obj->document);
    {
    fprintf(_coverage_fout, "1373\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1369\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1370\n");
      fflush(_coverage_fout);
      }
      __z->value.lval = (long )(doc_prop->stricterror != 0);
      {
      fprintf(_coverage_fout, "1371\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1377\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1374\n");
      fflush(_coverage_fout);
      }
      __z___0 = *retval;
      {
      fprintf(_coverage_fout, "1375\n");
      fflush(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      fprintf(_coverage_fout, "1376\n");
      fflush(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1380\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_strict_error_checking_read(dom_object *obj , zval **retval ) ;
int dom_document_version_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  xmlDoc *docp ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  zend_uint tmp___0 ;
  xmlChar *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1357\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1358\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1359\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1340\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1341\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1342\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1360\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp->version != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1343\n");
    fflush(_coverage_fout);
    }
    (*xmlFree)((void *)((xmlChar *)docp->version));
  } else {
    {
    fprintf(_coverage_fout, "1344\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1361\n");
  fflush(_coverage_fout);
  }
  if ((int )newval->type != 6) {
    {
    fprintf(_coverage_fout, "1351\n");
    fflush(_coverage_fout);
    }
    tmp___0 = zval_refcount_p(newval);
    {
    fprintf(_coverage_fout, "1352\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 1U) {
      {
      fprintf(_coverage_fout, "1345\n");
      fflush(_coverage_fout);
      }
      value_copy = *newval;
      {
      fprintf(_coverage_fout, "1346\n");
      fflush(_coverage_fout);
      }
      _zval_copy_ctor(& value_copy);
      {
      fprintf(_coverage_fout, "1347\n");
      fflush(_coverage_fout);
      }
      newval = & value_copy;
    } else {
      {
      fprintf(_coverage_fout, "1348\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "1353\n");
    fflush(_coverage_fout);
    }
    if ((int )newval->type != 6) {
      {
      fprintf(_coverage_fout, "1349\n");
      fflush(_coverage_fout);
      }
      _convert_to_string(newval);
    } else {
      {
      fprintf(_coverage_fout, "1350\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "1354\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1362\n");
  fflush(_coverage_fout);
  }
  tmp___1 = xmlStrdup((xmlChar const   *)newval->value.str.val);
  {
  fprintf(_coverage_fout, "1363\n");
  fflush(_coverage_fout);
  }
  docp->version = (xmlChar const   *)tmp___1;
  {
  fprintf(_coverage_fout, "1364\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1355\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1356\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1365\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_version_write(dom_object *obj , zval *newval ) ;
int dom_document_version_read(dom_object *obj , zval **retval ) 
{ xmlDoc *docp ;
  char *version ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1333\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1334\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1335\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1318\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1319\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1320\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1336\n");
  fflush(_coverage_fout);
  }
  version = (char *)docp->version;
  {
  fprintf(_coverage_fout, "1337\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1321\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1322\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp___0;
    {
    fprintf(_coverage_fout, "1323\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1338\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )version != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1331\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1324\n");
      fflush(_coverage_fout);
      }
      __s = (char const   *)version;
      {
      fprintf(_coverage_fout, "1325\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1326\n");
      fflush(_coverage_fout);
      }
      tmp___1 = strlen(__s);
      {
      fprintf(_coverage_fout, "1327\n");
      fflush(_coverage_fout);
      }
      __z->value.str.len = (int )tmp___1;
      {
      fprintf(_coverage_fout, "1328\n");
      fflush(_coverage_fout);
      }
      tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
      {
      fprintf(_coverage_fout, "1329\n");
      fflush(_coverage_fout);
      }
      __z->value.str.val = (char *)tmp___2;
      {
      fprintf(_coverage_fout, "1330\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)6;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1332\n");
    fflush(_coverage_fout);
    }
    (*retval)->type = (unsigned char)0;
  }
  {
  fprintf(_coverage_fout, "1339\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_version_read(dom_object *obj , zval **retval ) ;
extern void __attribute__((__visibility__("default")))  convert_to_long(zval *op ) ;
int dom_document_standalone_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  xmlDoc *docp ;
  int standalone ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  zend_uint tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1308\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1309\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1310\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1295\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1296\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1297\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1311\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zval_refcount_p(newval);
  {
  fprintf(_coverage_fout, "1312\n");
  fflush(_coverage_fout);
  }
  if (tmp___0 > 1U) {
    {
    fprintf(_coverage_fout, "1298\n");
    fflush(_coverage_fout);
    }
    value_copy = *newval;
    {
    fprintf(_coverage_fout, "1299\n");
    fflush(_coverage_fout);
    }
    _zval_copy_ctor(& value_copy);
    {
    fprintf(_coverage_fout, "1300\n");
    fflush(_coverage_fout);
    }
    newval = & value_copy;
  } else {
    {
    fprintf(_coverage_fout, "1301\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1313\n");
  fflush(_coverage_fout);
  }
  convert_to_long(newval);
  {
  fprintf(_coverage_fout, "1314\n");
  fflush(_coverage_fout);
  }
  standalone = (int )newval->value.lval;
  {
  fprintf(_coverage_fout, "1315\n");
  fflush(_coverage_fout);
  }
  if (standalone > 0) {
    {
    fprintf(_coverage_fout, "1302\n");
    fflush(_coverage_fout);
    }
    docp->standalone = 1;
  } else {
    {
    fprintf(_coverage_fout, "1305\n");
    fflush(_coverage_fout);
    }
    if (standalone < 0) {
      {
      fprintf(_coverage_fout, "1303\n");
      fflush(_coverage_fout);
      }
      docp->standalone = -1;
    } else {
      {
      fprintf(_coverage_fout, "1304\n");
      fflush(_coverage_fout);
      }
      docp->standalone = 0;
    }
  }
  {
  fprintf(_coverage_fout, "1316\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1306\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1307\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1317\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_standalone_write(dom_object *obj , zval *newval ) ;
int dom_document_standalone_read(dom_object *obj , zval **retval ) 
{ xmlDoc *docp ;
  int standalone ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1288\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1289\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1290\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1279\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1280\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1281\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1291\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1282\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1283\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp___0;
    {
    fprintf(_coverage_fout, "1284\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1292\n");
  fflush(_coverage_fout);
  }
  standalone = docp->standalone;
  {
  fprintf(_coverage_fout, "1293\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1285\n");
    fflush(_coverage_fout);
    }
    __z = *retval;
    {
    fprintf(_coverage_fout, "1286\n");
    fflush(_coverage_fout);
    }
    __z->value.lval = (long )(standalone != 0);
    {
    fprintf(_coverage_fout, "1287\n");
    fflush(_coverage_fout);
    }
    __z->type = (unsigned char)3;
    break;
  }
  {
  fprintf(_coverage_fout, "1294\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_standalone_read(dom_object *obj , zval **retval ) ;
struct _xmlCharEncodingHandler;
typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler;
typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr;
extern int xmlCharEncCloseFunc(xmlCharEncodingHandler *handler ) ;
extern xmlCharEncodingHandlerPtr xmlFindCharEncodingHandler(char const   *name ) ;
int dom_document_encoding_write(dom_object *obj , zval *newval ) 
{ zval value_copy ;
  xmlDoc *docp ;
  xmlCharEncodingHandlerPtr handler ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  zend_uint tmp___0 ;
  xmlChar *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1271\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1272\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1273\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1249\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1250\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1251\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1274\n");
  fflush(_coverage_fout);
  }
  if ((int )newval->type != 6) {
    {
    fprintf(_coverage_fout, "1258\n");
    fflush(_coverage_fout);
    }
    tmp___0 = zval_refcount_p(newval);
    {
    fprintf(_coverage_fout, "1259\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 1U) {
      {
      fprintf(_coverage_fout, "1252\n");
      fflush(_coverage_fout);
      }
      value_copy = *newval;
      {
      fprintf(_coverage_fout, "1253\n");
      fflush(_coverage_fout);
      }
      _zval_copy_ctor(& value_copy);
      {
      fprintf(_coverage_fout, "1254\n");
      fflush(_coverage_fout);
      }
      newval = & value_copy;
    } else {
      {
      fprintf(_coverage_fout, "1255\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "1260\n");
    fflush(_coverage_fout);
    }
    if ((int )newval->type != 6) {
      {
      fprintf(_coverage_fout, "1256\n");
      fflush(_coverage_fout);
      }
      _convert_to_string(newval);
    } else {
      {
      fprintf(_coverage_fout, "1257\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "1261\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1275\n");
  fflush(_coverage_fout);
  }
  handler = xmlFindCharEncodingHandler((char const   *)newval->value.str.val);
  {
  fprintf(_coverage_fout, "1276\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )handler != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1264\n");
    fflush(_coverage_fout);
    }
    xmlCharEncCloseFunc(handler);
    {
    fprintf(_coverage_fout, "1265\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )docp->encoding != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "1262\n");
      fflush(_coverage_fout);
      }
      (*xmlFree)((void *)((xmlChar *)docp->encoding));
    } else {
      {
      fprintf(_coverage_fout, "1263\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "1266\n");
    fflush(_coverage_fout);
    }
    tmp___1 = xmlStrdup((xmlChar const   *)newval->value.str.val);
    {
    fprintf(_coverage_fout, "1267\n");
    fflush(_coverage_fout);
    }
    docp->encoding = (xmlChar const   *)tmp___1;
  } else {
    {
    fprintf(_coverage_fout, "1268\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Invalid Document Encoding");
  }
  {
  fprintf(_coverage_fout, "1277\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )newval == (unsigned int )(& value_copy)) {
    {
    fprintf(_coverage_fout, "1269\n");
    fflush(_coverage_fout);
    }
    _zval_dtor(newval);
  } else {
    {
    fprintf(_coverage_fout, "1270\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1278\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_encoding_write(dom_object *obj , zval *newval ) ;
int dom_document_encoding_read(dom_object *obj , zval **retval ) 
{ xmlDoc *docp ;
  char *encoding ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1242\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1243\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1244\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1227\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1228\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1229\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1245\n");
  fflush(_coverage_fout);
  }
  encoding = (char *)docp->encoding;
  {
  fprintf(_coverage_fout, "1246\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1230\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1231\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp___0;
    {
    fprintf(_coverage_fout, "1232\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1247\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )encoding != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1240\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1233\n");
      fflush(_coverage_fout);
      }
      __s = (char const   *)encoding;
      {
      fprintf(_coverage_fout, "1234\n");
      fflush(_coverage_fout);
      }
      __z = *retval;
      {
      fprintf(_coverage_fout, "1235\n");
      fflush(_coverage_fout);
      }
      tmp___1 = strlen(__s);
      {
      fprintf(_coverage_fout, "1236\n");
      fflush(_coverage_fout);
      }
      __z->value.str.len = (int )tmp___1;
      {
      fprintf(_coverage_fout, "1237\n");
      fflush(_coverage_fout);
      }
      tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
      {
      fprintf(_coverage_fout, "1238\n");
      fflush(_coverage_fout);
      }
      __z->value.str.val = (char *)tmp___2;
      {
      fprintf(_coverage_fout, "1239\n");
      fflush(_coverage_fout);
      }
      __z->type = (unsigned char)6;
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "1241\n");
    fflush(_coverage_fout);
    }
    (*retval)->type = (unsigned char)0;
  }
  {
  fprintf(_coverage_fout, "1248\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_encoding_read(dom_object *obj , zval **retval ) ;
int dom_document_document_element_read(dom_object *obj , zval **retval ) 
{ xmlDoc *docp ;
  xmlNode *root ;
  int ret ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *tmp___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1216\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1217\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1218\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1204\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1205\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1206\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1219\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1207\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1208\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp___0;
    {
    fprintf(_coverage_fout, "1209\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1220\n");
  fflush(_coverage_fout);
  }
  root = xmlDocGetRootElement(docp);
  {
  fprintf(_coverage_fout, "1221\n");
  fflush(_coverage_fout);
  }
  if (! root) {
    {
    fprintf(_coverage_fout, "1210\n");
    fflush(_coverage_fout);
    }
    (*retval)->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1211\n");
    fflush(_coverage_fout);
    }
    return (0);
  } else {
    {
    fprintf(_coverage_fout, "1212\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1222\n");
  fflush(_coverage_fout);
  }
  tmp___2 = php_dom_create_object(root, & ret, (zval *)((void *)0), *retval, obj);
  {
  fprintf(_coverage_fout, "1223\n");
  fflush(_coverage_fout);
  }
  tmp___1 = (zval *)tmp___2;
  {
  fprintf(_coverage_fout, "1224\n");
  fflush(_coverage_fout);
  }
  *retval = tmp___1;
  {
  fprintf(_coverage_fout, "1225\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )tmp___1) {
    {
    fprintf(_coverage_fout, "1213\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1214\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1215\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1226\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_document_element_read(dom_object *obj , zval **retval ) ;
extern void php_dom_create_implementation(zval **retval ) ;
int dom_document_implementation_read(dom_object *obj , zval **retval ) 
{ void __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1201\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1198\n");
    fflush(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1199\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp;
    {
    fprintf(_coverage_fout, "1200\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1202\n");
  fflush(_coverage_fout);
  }
  php_dom_create_implementation(retval);
  {
  fprintf(_coverage_fout, "1203\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_implementation_read(dom_object *obj , zval **retval ) ;
typedef struct _xmlDtd xmlDtd;
typedef xmlDtd *xmlDtdPtr;
extern xmlDtdPtr xmlGetIntSubset(xmlDocPtr doc ) ;
int dom_document_doctype_read(dom_object *obj , zval **retval ) 
{ xmlDoc *docp ;
  xmlDtdPtr dtdptr ;
  int ret ;
  xmlNodePtr __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *tmp___1 ;
  zval __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1187\n");
  fflush(_coverage_fout);
  }
  tmp = dom_object_get_node(obj);
  {
  fprintf(_coverage_fout, "1188\n");
  fflush(_coverage_fout);
  }
  docp = (xmlDoc *)tmp;
  {
  fprintf(_coverage_fout, "1189\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )docp == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "1175\n");
    fflush(_coverage_fout);
    }
    php_dom_throw_error(11, 0);
    {
    fprintf(_coverage_fout, "1176\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1177\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1190\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1178\n");
    fflush(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    fprintf(_coverage_fout, "1179\n");
    fflush(_coverage_fout);
    }
    *retval = (zval *)tmp___0;
    {
    fprintf(_coverage_fout, "1180\n");
    fflush(_coverage_fout);
    }
    ((zval_gc_info *)*retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  fprintf(_coverage_fout, "1191\n");
  fflush(_coverage_fout);
  }
  dtdptr = xmlGetIntSubset(docp);
  {
  fprintf(_coverage_fout, "1192\n");
  fflush(_coverage_fout);
  }
  if (! dtdptr) {
    {
    fprintf(_coverage_fout, "1181\n");
    fflush(_coverage_fout);
    }
    (*retval)->type = (unsigned char)0;
    {
    fprintf(_coverage_fout, "1182\n");
    fflush(_coverage_fout);
    }
    return (0);
  } else {
    {
    fprintf(_coverage_fout, "1183\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1193\n");
  fflush(_coverage_fout);
  }
  tmp___2 = php_dom_create_object((xmlNode *)dtdptr, & ret, (zval *)((void *)0),
                                  *retval, obj);
  {
  fprintf(_coverage_fout, "1194\n");
  fflush(_coverage_fout);
  }
  tmp___1 = (zval *)tmp___2;
  {
  fprintf(_coverage_fout, "1195\n");
  fflush(_coverage_fout);
  }
  *retval = tmp___1;
  {
  fprintf(_coverage_fout, "1196\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((void *)0) == (unsigned int )tmp___1) {
    {
    fprintf(_coverage_fout, "1184\n");
    fflush(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Cannot create required DOM object");
    {
    fprintf(_coverage_fout, "1185\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "1186\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1197\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
int dom_document_doctype_read(dom_object *obj , zval **retval ) ;
struct _zend_arg_info;
struct _zend_function_entry {
   char const   *fname ;
   void (*handler)(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
   struct _zend_arg_info  const  *arg_info ;
   zend_uint num_args ;
   zend_uint flags ;
};
typedef struct _zend_function_entry zend_function_entry;
struct _zend_arg_info {
   char const   *name ;
   zend_uint name_len ;
   char const   *class_name ;
   zend_uint class_name_len ;
   zend_uchar type_hint ;
   zend_bool allow_null ;
   zend_bool pass_by_reference ;
};
typedef struct _zend_arg_info zend_arg_info;
static zend_arg_info const   arginfo_dom_document_registernodeclass[3] ;
static zend_arg_info const   arginfo_dom_document_relaxNG_validate_xml[2] ;
static zend_arg_info const   arginfo_dom_document_relaxNG_validate_file[2] ;
static zend_arg_info const   arginfo_dom_document_schema_validate_xml[2] ;
static zend_arg_info const   arginfo_dom_document_schema_validate_file[2] ;
static zend_arg_info const   arginfo_dom_document_savehtmlfile[2] ;
static zend_arg_info const   arginfo_dom_document_savehtml[1] ;
static zend_arg_info const   arginfo_dom_document_loadhtmlfile[2] ;
static zend_arg_info const   arginfo_dom_document_loadhtml[2] ;
static zend_arg_info const   arginfo_dom_document_xinclude[2] ;
static zend_arg_info const   arginfo_dom_document_validate[1] ;
static zend_arg_info const   arginfo_dom_document_construct[3] ;
static zend_arg_info const   arginfo_dom_document_savexml[2] ;
static zend_arg_info const   arginfo_dom_document_loadxml[3] ;
static zend_arg_info const   arginfo_dom_document_save[2] ;
static zend_arg_info const   arginfo_dom_document_load[3] ;
static zend_arg_info const   arginfo_dom_document_rename_node[4] ;
static zend_arg_info const   arginfo_dom_document_normalize_document[1] ;
static zend_arg_info const   arginfo_dom_document_adopt_node[2] ;
static zend_arg_info const   arginfo_dom_document_get_element_by_id[2] ;
static zend_arg_info const   arginfo_dom_document_get_elements_by_tag_name_ns[3] ;
static zend_arg_info const   arginfo_dom_document_create_attribute_ns[3] ;
static zend_arg_info const   arginfo_dom_document_create_element_ns[4] ;
static zend_arg_info const   arginfo_dom_document_import_node[3] ;
static zend_arg_info const   arginfo_dom_document_get_elements_by_tag_name[2] ;
static zend_arg_info const   arginfo_dom_document_create_entity_reference[2] ;
static zend_arg_info const   arginfo_dom_document_create_attribute[2] ;
static zend_arg_info const   arginfo_dom_document_create_processing_instruction[3] ;
static zend_arg_info const   arginfo_dom_document_create_cdatasection[2] ;
static zend_arg_info const   arginfo_dom_document_create_comment[2] ;
static zend_arg_info const   arginfo_dom_document_create_text_node[2] ;
static zend_arg_info const   arginfo_dom_document_create_document_fragment[1] ;
static zend_arg_info const   arginfo_dom_document_create_element[3] ;
zend_function_entry const   php_dom_document_class_functions[34]  = 
  {      {"createElement", & zif_dom_document_create_element,
      arginfo_dom_document_create_element,
      sizeof(arginfo_dom_document_create_element) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createDocumentFragment", & zif_dom_document_create_document_fragment,
      arginfo_dom_document_create_document_fragment,
      sizeof(arginfo_dom_document_create_document_fragment) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createTextNode", & zif_dom_document_create_text_node,
      arginfo_dom_document_create_text_node,
      sizeof(arginfo_dom_document_create_text_node) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createComment", & zif_dom_document_create_comment,
      arginfo_dom_document_create_comment,
      sizeof(arginfo_dom_document_create_comment) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createCDATASection", & zif_dom_document_create_cdatasection,
      arginfo_dom_document_create_cdatasection,
      sizeof(arginfo_dom_document_create_cdatasection) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createProcessingInstruction",
      & zif_dom_document_create_processing_instruction,
      arginfo_dom_document_create_processing_instruction,
      sizeof(arginfo_dom_document_create_processing_instruction) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createAttribute", & zif_dom_document_create_attribute,
      arginfo_dom_document_create_attribute,
      sizeof(arginfo_dom_document_create_attribute) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createEntityReference", & zif_dom_document_create_entity_reference,
      arginfo_dom_document_create_entity_reference,
      sizeof(arginfo_dom_document_create_entity_reference) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getElementsByTagName", & zif_dom_document_get_elements_by_tag_name,
      arginfo_dom_document_get_elements_by_tag_name,
      sizeof(arginfo_dom_document_get_elements_by_tag_name) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"importNode", & zif_dom_document_import_node,
      arginfo_dom_document_import_node,
      sizeof(arginfo_dom_document_import_node) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createElementNS", & zif_dom_document_create_element_ns,
      arginfo_dom_document_create_element_ns,
      sizeof(arginfo_dom_document_create_element_ns) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createAttributeNS", & zif_dom_document_create_attribute_ns,
      arginfo_dom_document_create_attribute_ns,
      sizeof(arginfo_dom_document_create_attribute_ns) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getElementsByTagNameNS", & zif_dom_document_get_elements_by_tag_name_ns,
      arginfo_dom_document_get_elements_by_tag_name_ns,
      sizeof(arginfo_dom_document_get_elements_by_tag_name_ns) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getElementById", & zif_dom_document_get_element_by_id,
      arginfo_dom_document_get_element_by_id,
      sizeof(arginfo_dom_document_get_element_by_id) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"adoptNode", & zif_dom_document_adopt_node,
      arginfo_dom_document_adopt_node,
      sizeof(arginfo_dom_document_adopt_node) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"normalizeDocument", & zif_dom_document_normalize_document,
      arginfo_dom_document_normalize_document,
      sizeof(arginfo_dom_document_normalize_document) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"renameNode", & zif_dom_document_rename_node,
      arginfo_dom_document_rename_node,
      sizeof(arginfo_dom_document_rename_node) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"load", & zim_domdocument_load, arginfo_dom_document_load,
      sizeof(arginfo_dom_document_load) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )65792}, 
        {"save", & zif_dom_document_save, arginfo_dom_document_save,
      sizeof(arginfo_dom_document_save) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"loadXML", & zim_domdocument_loadXML, arginfo_dom_document_loadxml,
      sizeof(arginfo_dom_document_loadxml) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )65792}, 
        {"saveXML", & zif_dom_document_savexml, arginfo_dom_document_savexml,
      sizeof(arginfo_dom_document_savexml) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"__construct", & zim_domdocument___construct,
      arginfo_dom_document_construct,
      sizeof(arginfo_dom_document_construct) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0x100}, 
        {"validate", & zif_dom_document_validate, arginfo_dom_document_validate,
      sizeof(arginfo_dom_document_validate) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"xinclude", & zif_dom_document_xinclude, arginfo_dom_document_xinclude,
      sizeof(arginfo_dom_document_xinclude) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"loadHTML", & zim_domdocument_loadHTML, arginfo_dom_document_loadhtml,
      sizeof(arginfo_dom_document_loadhtml) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )65792}, 
        {"loadHTMLFile", & zim_domdocument_loadHTMLFile,
      arginfo_dom_document_loadhtmlfile,
      sizeof(arginfo_dom_document_loadhtmlfile) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )65792}, 
        {"saveHTML", & zif_dom_document_save_html, arginfo_dom_document_savehtml,
      sizeof(arginfo_dom_document_savehtml) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"saveHTMLFile", & zif_dom_document_save_html_file,
      arginfo_dom_document_savehtmlfile,
      sizeof(arginfo_dom_document_savehtmlfile) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"schemaValidate", & zif_dom_document_schema_validate_file,
      arginfo_dom_document_schema_validate_file,
      sizeof(arginfo_dom_document_schema_validate_file) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"schemaValidateSource", & zif_dom_document_schema_validate_xml,
      arginfo_dom_document_schema_validate_xml,
      sizeof(arginfo_dom_document_schema_validate_xml) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"relaxNGValidate", & zif_dom_document_relaxNG_validate_file,
      arginfo_dom_document_relaxNG_validate_file,
      sizeof(arginfo_dom_document_relaxNG_validate_file) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"relaxNGValidateSource", & zif_dom_document_relaxNG_validate_xml,
      arginfo_dom_document_relaxNG_validate_xml,
      sizeof(arginfo_dom_document_relaxNG_validate_xml) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"registerNodeClass", & zim_domdocument_registerNodeClass,
      arginfo_dom_document_registernodeclass,
      sizeof(arginfo_dom_document_registernodeclass) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0x100}, 
        {(char const   *)((void *)0),
      (void (*)(int ht , zval *return_value ,
                zval **return_value_ptr , zval *this_ptr ,
                int return_value_used ))((void *)0),
      (struct _zend_arg_info  const  *)((void *)0), 0U, 0U}};
zend_function_entry const   php_dom_document_class_functions[34] ;
static zend_arg_info const   arginfo_dom_document_registernodeclass[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"baseClass", sizeof("baseClass") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"extendedClass", sizeof("extendedClass") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_relaxNG_validate_xml[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_relaxNG_validate_file[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_schema_validate_xml[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_schema_validate_file[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_savehtmlfile[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"file", sizeof("file") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_savehtml[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_loadhtmlfile[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_loadhtml[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_xinclude[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_validate[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_construct[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"version", sizeof("version") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"encoding", sizeof("encoding") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_savexml[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"node", sizeof("node") - 1U, "DOMNode", sizeof("DOMNode") - 1U,
      (zend_uchar )10, (zend_bool )1, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_loadxml[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_save[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"file", sizeof("file") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_load[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_rename_node[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"node", sizeof("node") - 1U, "DOMNode", sizeof("DOMNode") - 1U,
      (zend_uchar )10, (zend_bool )0, (zend_bool )0}, 
        {"namespaceURI", sizeof("namespaceURI") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"qualifiedName", sizeof("qualifiedName") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_normalize_document[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_adopt_node[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, "DOMNode", sizeof("DOMNode") - 1U,
      (zend_uchar )10, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_get_element_by_id[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"elementId", sizeof("elementId") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_get_elements_by_tag_name_ns[3]  = {      {(char const   *)((void *)0),
      (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0,
      (zend_bool )0, (zend_bool )0}, 
        {"namespaceURI", sizeof("namespaceURI") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"localName", sizeof("localName") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_attribute_ns[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"namespaceURI", sizeof("namespaceURI") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"qualifiedName", sizeof("qualifiedName") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_element_ns[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"namespaceURI", sizeof("namespaceURI") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"qualifiedName", sizeof("qualifiedName") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_import_node[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"importedNode", sizeof("importedNode") - 1U, "DOMNode",
      sizeof("DOMNode") - 1U, (zend_uchar )10, (zend_bool )0, (zend_bool )0}, 
        {"deep", sizeof("deep") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_get_elements_by_tag_name[2]  = {      {(char const   *)((void *)0),
      (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0,
      (zend_bool )0, (zend_bool )0}, 
        {"tagName", sizeof("tagName") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_entity_reference[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_attribute[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_processing_instruction[3]  = {      {(char const   *)((void *)0),
      (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0,
      (zend_bool )0, (zend_bool )0}, 
        {"target", sizeof("target") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_cdatasection[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_comment[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_text_node[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_document_fragment[1]  = {      {(char const   *)((void *)0),
      (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0,
      (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dom_document_create_element[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"tagName", sizeof("tagName") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
struct _xmlSchemaSAXPlug;
typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct;
typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr;
extern int xmlSchemaSAXUnplug(xmlSchemaSAXPlugPtr plug ) ;
typedef struct _xmlSAXHandler xmlSAXHandler;
typedef xmlSAXHandler *xmlSAXHandlerPtr;
extern xmlSchemaSAXPlugPtr xmlSchemaSAXPlug(xmlSchemaValidCtxtPtr ctxt ,
                                            xmlSAXHandlerPtr *sax ,
                                            void **user_data ) ;
extern xmlParserCtxtPtr xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt ) ;
extern int xmlSchemaValidateFile(xmlSchemaValidCtxtPtr ctxt ,
                                 char const   *filename , int options ) ;
enum __anonenum_xmlCharEncoding_95;
typedef enum __anonenum_xmlCharEncoding_95 xmlCharEncoding;
struct _xmlParserInputBuffer;
typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
extern int xmlSchemaValidateStream(xmlSchemaValidCtxtPtr ctxt ,
                                   xmlParserInputBufferPtr input ,
                                   xmlCharEncoding enc , xmlSAXHandlerPtr sax ,
                                   void *user_data ) ;
extern int xmlSchemaValidateOneElement(xmlSchemaValidCtxtPtr ctxt ,
                                       xmlNodePtr elem ) ;
extern int xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt ) ;
extern int xmlSchemaSetValidOptions(xmlSchemaValidCtxtPtr ctxt , int options ) ;
typedef void ( /* format attribute */  (*xmlSchemaValidityWarningFunc))(void *ctx ,
                                                                        char const   *msg 
                                                                        , ...);
typedef void ( /* format attribute */  (*xmlSchemaValidityErrorFunc))(void *ctx ,
                                                                      char const   *msg 
                                                                      , ...);
extern int xmlSchemaGetValidErrors(xmlSchemaValidCtxtPtr ctxt ,
                                   xmlSchemaValidityErrorFunc *err ,
                                   xmlSchemaValidityWarningFunc *warn ,
                                   void **ctx ) ;
extern void xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt ,
                                              void (*serror)(void *userData ,
                                                             xmlErrorPtr error ) ,
                                              void *ctx ) ;
extern void xmlSchemaDump(FILE *output , xmlSchemaPtr schema ) ;
extern int xmlSchemaIsValid(xmlSchemaValidCtxtPtr ctxt ) ;
extern int xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt ,
                                    xmlSchemaValidityErrorFunc *err ,
                                    xmlSchemaValidityWarningFunc *warn ,
                                    void **ctx ) ;
extern void xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt ,
                                               void (*serror)(void *userData ,
                                                              xmlErrorPtr error ) ,
                                               void *ctx ) ;
extern xmlSchemaParserCtxtPtr xmlSchemaNewDocParserCtxt(xmlDocPtr doc ) ;
extern int xmlRelaxNGValidateFullElement(xmlRelaxNGValidCtxtPtr ctxt ,
                                         xmlDocPtr doc , xmlNodePtr elem ) ;
extern int xmlRelaxNGValidatePopElement(xmlRelaxNGValidCtxtPtr ctxt ,
                                        xmlDocPtr doc , xmlNodePtr elem ) ;
extern int xmlRelaxNGValidatePushCData(xmlRelaxNGValidCtxtPtr ctxt ,
                                       xmlChar const   *data , int len ) ;
extern int xmlRelaxNGValidatePushElement(xmlRelaxNGValidCtxtPtr ctxt ,
                                         xmlDocPtr doc , xmlNodePtr elem ) ;
extern void xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt ,
                                               void (*serror)(void *userData ,
                                                              xmlErrorPtr error ) ,
                                               void *ctx ) ;
typedef void ( /* format attribute */  (*xmlRelaxNGValidityWarningFunc))(void *ctx ,
                                                                         char const   *msg 
                                                                         , ...);
typedef void ( /* format attribute */  (*xmlRelaxNGValidityErrorFunc))(void *ctx ,
                                                                       char const   *msg 
                                                                       , ...);
extern int xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt ,
                                    xmlRelaxNGValidityErrorFunc *err ,
                                    xmlRelaxNGValidityWarningFunc *warn ,
                                    void **ctx ) ;
extern void xmlRelaxNGDumpTree(FILE *output , xmlRelaxNGPtr schema ) ;
extern void xmlRelaxNGDump(FILE *output , xmlRelaxNGPtr schema ) ;
extern void xmlRelaxNGSetParserStructuredErrors(xmlRelaxNGParserCtxtPtr ctxt ,
                                                void (*serror)(void *userData ,
                                                               xmlErrorPtr error ) ,
                                                void *ctx ) ;
extern int xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt ,
                                     xmlRelaxNGValidityErrorFunc *err ,
                                     xmlRelaxNGValidityWarningFunc *warn ,
                                     void **ctx ) ;
extern int xmlRelaxParserSetFlag(xmlRelaxNGParserCtxtPtr ctxt , int flag ) ;
extern xmlRelaxNGParserCtxtPtr xmlRelaxNGNewDocParserCtxt(xmlDocPtr doc ) ;
extern void xmlRelaxNGCleanupTypes(void) ;
extern int xmlRelaxNGInitTypes(void) ;
typedef struct _zend_module_entry zend_module_entry;
extern void zm_info_dom(zend_module_entry *zend_module ) ;
extern int zm_shutdown_dom(int type , int module_number ) ;
extern int zm_startup_dom(int type , int module_number ) ;
extern zend_object_iterator *php_dom_get_iterator(zend_class_entry *ce ,
                                                  zval *object , int by_ref ) ;
extern xmlNode *php_dom_libxml_notation_iter(xmlHashTable *ht , int index ) ;
extern xmlNode *php_dom_libxml_hash_iter(xmlHashTable *ht , int index ) ;
extern xmlNodePtr create_notation(xmlChar const   *name ,
                                  xmlChar const   *ExternalID ,
                                  xmlChar const   *SystemID ) ;
extern int dom_node_children_valid(xmlNodePtr node ) ;
extern int dom_node_is_read_only(xmlNodePtr node ) ;
extern int dom_has_feature(char *feature , char *version ) ;
extern int dom_hierarchy(xmlNodePtr parent , xmlNodePtr child ) ;
extern xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep ,
                                                    char *ns , char *local ,
                                                    int *cur , int index ) ;
extern xmlNsPtr dom_get_nsdecl(xmlNode *node , xmlChar *localName ) ;
extern void dom_set_old_ns(xmlDoc *doc , xmlNs *ns ) ;
extern void node_list_unlink(xmlNodePtr node ) ;
extern void php_dom_throw_error_with_message(int error_code ,
                                             char *error_message ,
                                             int strict_error ) ;
struct _zend_object_value;
extern zend_object_value dom_xpath_objects_new(zend_class_entry *class_type ) ;
extern zend_object_value dom_nnodemap_objects_new(zend_class_entry *class_type ) ;
extern zend_object_value dom_objects_new(zend_class_entry *class_type ) ;
extern dom_object *dom_object_get_data(xmlNodePtr obj ) ;
extern void zif_dom_xpath_register_php_functions(int ht , zval *return_value ,
                                                 zval **return_value_ptr ,
                                                 zval *this_ptr ,
                                                 int return_value_used ) ;
extern void zif_dom_xpath_evaluate(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_dom_xpath_query(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
extern void zif_dom_xpath_register_ns(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zim_domxpath___construct(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void zif_dom_string_extend_find_offset32(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zif_dom_string_extend_find_offset16(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zim_domprocessinginstruction___construct(int ht ,
                                                     zval *return_value ,
                                                     zval **return_value_ptr ,
                                                     zval *this_ptr ,
                                                     int return_value_used ) ;
extern void zim_domentityreference___construct(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern void zim_domcdatasection___construct(int ht , zval *return_value ,
                                            zval **return_value_ptr ,
                                            zval *this_ptr ,
                                            int return_value_used ) ;
extern void zif_dom_domconfiguration_can_set_parameter(int ht ,
                                                       zval *return_value ,
                                                       zval **return_value_ptr ,
                                                       zval *this_ptr ,
                                                       int return_value_used ) ;
extern void zif_dom_domconfiguration_get_parameter(int ht , zval *return_value ,
                                                   zval **return_value_ptr ,
                                                   zval *this_ptr ,
                                                   int return_value_used ) ;
extern void zif_dom_domconfiguration_set_parameter(int ht , zval *return_value ,
                                                   zval **return_value_ptr ,
                                                   zval *this_ptr ,
                                                   int return_value_used ) ;
extern void zif_dom_domerrorhandler_handle_error(int ht , zval *return_value ,
                                                 zval **return_value_ptr ,
                                                 zval *this_ptr ,
                                                 int return_value_used ) ;
extern void zif_dom_userdatahandler_handle(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used ) ;
extern void zim_domcomment___construct(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zim_domtext___construct(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zif_dom_text_replace_whole_text(int ht , zval *return_value ,
                                            zval **return_value_ptr ,
                                            zval *this_ptr ,
                                            int return_value_used ) ;
extern void zif_dom_text_is_whitespace_in_element_content(int ht ,
                                                          zval *return_value ,
                                                          zval **return_value_ptr ,
                                                          zval *this_ptr ,
                                                          int return_value_used ) ;
extern void zif_dom_text_split_text(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zim_domelement___construct(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_dom_element_set_id_attribute_node(int ht , zval *return_value ,
                                                  zval **return_value_ptr ,
                                                  zval *this_ptr ,
                                                  int return_value_used ) ;
extern void zif_dom_element_set_id_attribute_ns(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zif_dom_element_set_id_attribute(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_dom_element_has_attribute_ns(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_dom_element_has_attribute(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern void zif_dom_element_get_elements_by_tag_name_ns(int ht ,
                                                        zval *return_value ,
                                                        zval **return_value_ptr ,
                                                        zval *this_ptr ,
                                                        int return_value_used ) ;
extern void zif_dom_element_set_attribute_node_ns(int ht , zval *return_value ,
                                                  zval **return_value_ptr ,
                                                  zval *this_ptr ,
                                                  int return_value_used ) ;
extern void zif_dom_element_get_attribute_node_ns(int ht , zval *return_value ,
                                                  zval **return_value_ptr ,
                                                  zval *this_ptr ,
                                                  int return_value_used ) ;
extern void zif_dom_element_remove_attribute_ns(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zif_dom_element_set_attribute_ns(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_dom_element_get_attribute_ns(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_dom_element_get_elements_by_tag_name(int ht ,
                                                     zval *return_value ,
                                                     zval **return_value_ptr ,
                                                     zval *this_ptr ,
                                                     int return_value_used ) ;
extern void zif_dom_element_remove_attribute_node(int ht , zval *return_value ,
                                                  zval **return_value_ptr ,
                                                  zval *this_ptr ,
                                                  int return_value_used ) ;
extern void zif_dom_element_set_attribute_node(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern void zif_dom_element_get_attribute_node(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern void zif_dom_element_remove_attribute(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_dom_element_set_attribute(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern void zif_dom_element_get_attribute(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern void zim_domattr___construct(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zif_dom_attr_is_id(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_dom_characterdata_replace_data(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern void zif_dom_characterdata_delete_data(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
extern void zif_dom_characterdata_insert_data(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
extern void zif_dom_characterdata_append_data(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
extern void zif_dom_characterdata_substring_data(int ht , zval *return_value ,
                                                 zval **return_value_ptr ,
                                                 zval *this_ptr ,
                                                 int return_value_used ) ;
extern void zif_dom_namednodemap_remove_named_item_ns(int ht ,
                                                      zval *return_value ,
                                                      zval **return_value_ptr ,
                                                      zval *this_ptr ,
                                                      int return_value_used ) ;
extern void zif_dom_namednodemap_set_named_item_ns(int ht , zval *return_value ,
                                                   zval **return_value_ptr ,
                                                   zval *this_ptr ,
                                                   int return_value_used ) ;
extern void zif_dom_namednodemap_get_named_item_ns(int ht , zval *return_value ,
                                                   zval **return_value_ptr ,
                                                   zval *this_ptr ,
                                                   int return_value_used ) ;
extern void zif_dom_namednodemap_item(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_dom_namednodemap_remove_named_item(int ht , zval *return_value ,
                                                   zval **return_value_ptr ,
                                                   zval *this_ptr ,
                                                   int return_value_used ) ;
extern void zif_dom_namednodemap_set_named_item(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zif_dom_namednodemap_get_named_item(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zif_dom_nodelist_item(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void zim_domnode_getLineNo(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void zim_domnode_getNodePath(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zim_domnode_C14NFile(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zim_domnode_C14N(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_dom_node_get_user_data(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_set_user_data(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_get_feature(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void zif_dom_node_is_equal_node(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_lookup_namespace_uri(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
extern void zif_dom_node_is_default_namespace(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
extern void zif_dom_node_lookup_prefix(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_is_same_node(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_dom_node_compare_document_position(int ht , zval *return_value ,
                                                   zval **return_value_ptr ,
                                                   zval *this_ptr ,
                                                   int return_value_used ) ;
extern void zif_dom_node_has_attributes(int ht , zval *return_value ,
                                        zval **return_value_ptr ,
                                        zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_is_supported(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_dom_node_normalize(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_dom_node_clone_node(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zif_dom_node_has_child_nodes(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_append_child(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_dom_node_remove_child(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_dom_node_replace_child(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_dom_node_insert_before(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zim_domdocumentfragment_appendXML(int ht , zval *return_value ,
                                              zval **return_value_ptr ,
                                              zval *this_ptr ,
                                              int return_value_used ) ;
extern void zim_domdocumentfragment___construct(int ht , zval *return_value ,
                                                zval **return_value_ptr ,
                                                zval *this_ptr ,
                                                int return_value_used ) ;
extern void zim_domimplementation_getFeature(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zim_domimplementation_createDocument(int ht , zval *return_value ,
                                                 zval **return_value_ptr ,
                                                 zval *this_ptr ,
                                                 int return_value_used ) ;
extern void zim_domimplementation_createDocumentType(int ht ,
                                                     zval *return_value ,
                                                     zval **return_value_ptr ,
                                                     zval *this_ptr ,
                                                     int return_value_used ) ;
extern void zim_domimplementation_hasFeature(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_dom_domimplementationsource_get_domimplementations(int ht ,
                                                                   zval *return_value ,
                                                                   zval **return_value_ptr ,
                                                                   zval *this_ptr ,
                                                                   int return_value_used ) ;
extern void zif_dom_domimplementationsource_get_domimplementation(int ht ,
                                                                  zval *return_value ,
                                                                  zval **return_value_ptr ,
                                                                  zval *this_ptr ,
                                                                  int return_value_used ) ;
extern void zif_dom_domimplementationlist_item(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern void zif_dom_namelist_get_namespace_uri(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
extern void zif_dom_namelist_get_name(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_dom_domstringlist_item(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern zend_function_entry const   php_dom_xpath_class_functions[] ;
extern zend_function_entry const   php_dom_string_extend_class_functions[] ;
extern zend_function_entry const   php_dom_processinginstruction_class_functions[] ;
extern zend_function_entry const   php_dom_entityreference_class_functions[] ;
extern zend_function_entry const   php_dom_entity_class_functions[] ;
extern zend_function_entry const   php_dom_notation_class_functions[] ;
extern zend_function_entry const   php_dom_documenttype_class_functions[] ;
extern zend_function_entry const   php_dom_cdatasection_class_functions[] ;
extern zend_function_entry const   php_dom_domconfiguration_class_functions[] ;
extern zend_function_entry const   php_dom_domlocator_class_functions[] ;
extern zend_function_entry const   php_dom_domerrorhandler_class_functions[] ;
extern zend_function_entry const   php_dom_domerror_class_functions[] ;
extern zend_function_entry const   php_dom_userdatahandler_class_functions[] ;
extern zend_function_entry const   php_dom_typeinfo_class_functions[] ;
extern zend_function_entry const   php_dom_comment_class_functions[] ;
extern zend_function_entry const   php_dom_text_class_functions[] ;
extern zend_function_entry const   php_dom_element_class_functions[] ;
extern zend_function_entry const   php_dom_attr_class_functions[] ;
extern zend_function_entry const   php_dom_characterdata_class_functions[] ;
extern zend_function_entry const   php_dom_namednodemap_class_functions[] ;
extern zend_function_entry const   php_dom_nodelist_class_functions[] ;
extern zend_function_entry const   php_dom_node_class_functions[] ;
extern zend_function_entry const   php_dom_documentfragment_class_functions[] ;
extern zend_function_entry const   php_dom_domimplementation_class_functions[] ;
extern zend_function_entry const   php_dom_domimplementationsource_class_functions[] ;
extern zend_function_entry const   php_dom_domimplementationlist_class_functions[] ;
extern zend_function_entry const   php_dom_namelist_class_functions[] ;
extern zend_function_entry const   php_dom_domstringlist_class_functions[] ;
extern zend_function_entry const   php_dom_domexception_class_functions[] ;
extern zend_class_entry *dom_namespace_node_class_entry ;
extern zend_class_entry *dom_xpath_class_entry ;
extern zend_class_entry *dom_string_extend_class_entry ;
extern zend_class_entry *dom_processinginstruction_class_entry ;
extern zend_class_entry *dom_entityreference_class_entry ;
extern zend_class_entry *dom_entity_class_entry ;
extern zend_class_entry *dom_notation_class_entry ;
extern zend_class_entry *dom_documenttype_class_entry ;
extern zend_class_entry *dom_cdatasection_class_entry ;
extern zend_class_entry *dom_domconfiguration_class_entry ;
extern zend_class_entry *dom_domlocator_class_entry ;
extern zend_class_entry *dom_domerrorhandler_class_entry ;
extern zend_class_entry *dom_domerror_class_entry ;
extern zend_class_entry *dom_userdatahandler_class_entry ;
extern zend_class_entry *dom_typeinfo_class_entry ;
extern zend_class_entry *dom_comment_class_entry ;
extern zend_class_entry *dom_text_class_entry ;
extern zend_class_entry *dom_element_class_entry ;
extern zend_class_entry *dom_attr_class_entry ;
extern zend_class_entry *dom_characterdata_class_entry ;
extern zend_class_entry *dom_namednodemap_class_entry ;
extern zend_class_entry *dom_nodelist_class_entry ;
extern zend_class_entry *dom_documentfragment_class_entry ;
extern zend_class_entry *dom_domimplementation_class_entry ;
extern zend_class_entry *dom_domimplementationsource_class_entry ;
extern zend_class_entry *dom_domimplementationlist_class_entry ;
extern zend_class_entry *dom_namelist_class_entry ;
extern zend_class_entry *dom_domstringlist_class_entry ;
extern int zend_spprintf(char **message , int max_len , char *format  , ...) ;
extern void __attribute__((__visibility__("default")))  zend_exception_error(zval *exception ,
                                                                             int severity ) ;
extern void __attribute__((__visibility__("default")))  (*zend_throw_exception_hook)(zval *ex ) ;
extern zval __attribute__((__visibility__("default")))  *zend_throw_error_exception(zend_class_entry *exception_ce ,
                                                                                    char *message ,
                                                                                    long code ,
                                                                                    int severity ) ;
extern void __attribute__((__visibility__("default")))  zend_clear_exception(void) ;
extern void __attribute__((__visibility__("default")))  zend_throw_exception_object(zval *exception ) ;
extern zval __attribute__((__visibility__("default")))  *zend_throw_exception_ex(zend_class_entry *exception_ce ,
                                                                                 long code ,
                                                                                 char *format 
                                                                                 , ...) ;
extern zval __attribute__((__visibility__("default")))  *zend_throw_exception(zend_class_entry *exception_ce ,
                                                                              char *message ,
                                                                              long code ) ;
extern void __attribute__((__visibility__("default")))  zend_register_default_classes(void) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_get_error_exception(void) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_exception_get_default(void) ;
extern void zend_register_default_exception(void) ;
extern void zend_throw_exception_internal(zval *exception ) ;
extern void __attribute__((__visibility__("default")))  zend_exception_restore(void) ;
extern void __attribute__((__visibility__("default")))  zend_exception_save(void) ;
extern void __attribute__((__visibility__("default")))  zend_exception_set_previous(zval *exception ,
                                                                                    zval *add_previous ) ;
extern dom_object __attribute__((__visibility__("default")))  *php_dom_object_get_data(xmlNodePtr obj ) ;
extern void __attribute__((__visibility__("default")))  php_libxml_shutdown(void) ;
extern void __attribute__((__visibility__("default")))  php_libxml_initialize(void) ;
extern void __attribute__((__visibility__("default")))  php_libxml_issue_error(int level ,
                                                                               char const   *msg ) ;
extern zval __attribute__((__visibility__("default")))  *php_libxml_switch_context(zval *context ) ;
extern int __attribute__((__visibility__("default")))  php_libxml_xmlCheckUTF8(unsigned char const   *s ) ;
extern void __attribute__((__visibility__("default")))  php_libxml_node_decrement_resource(php_libxml_node_object *object ) ;
extern int __attribute__((__visibility__("default")))  php_libxml_register_export(zend_class_entry *ce ,
                                                                                  void *(*export_function)(zval *object ) ) ;
extern xmlNodePtr __attribute__((__visibility__("default")))  php_libxml_import_node(zval *object ) ;
__inline static char *smart_str_print_unsigned(char *buf , long num ) 
{ char *r ;
  char *__p ;
  unsigned long __num ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1173\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1168\n");
    fflush(_coverage_fout);
    }
    __p = buf;
    {
    fprintf(_coverage_fout, "1169\n");
    fflush(_coverage_fout);
    }
    __num = (unsigned long )num;
    {
    fprintf(_coverage_fout, "1170\n");
    fflush(_coverage_fout);
    }
    *__p = (char )'\000';
    {
    fprintf(_coverage_fout, "1171\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1164\n");
      fflush(_coverage_fout);
      }
      __p --;
      {
      fprintf(_coverage_fout, "1165\n");
      fflush(_coverage_fout);
      }
      *__p = (char )((int )((char )(__num % 10UL)) + 48);
      {
      fprintf(_coverage_fout, "1166\n");
      fflush(_coverage_fout);
      }
      __num /= 10UL;
      {
      fprintf(_coverage_fout, "1167\n");
      fflush(_coverage_fout);
      }
      if (__num > 0UL) {
        {
        fprintf(_coverage_fout, "1163\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    fprintf(_coverage_fout, "1172\n");
    fflush(_coverage_fout);
    }
    r = __p;
    break;
  }
  {
  fprintf(_coverage_fout, "1174\n");
  fflush(_coverage_fout);
  }
  return (r);
}
}
__inline static char *smart_str_print_unsigned(char *buf , long num ) ;
__inline static char *smart_str_print_long(char *buf , long num ) 
{ char *r ;
  char *__p ;
  unsigned long __num ;
  char *__p___0 ;
  unsigned long __num___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1161\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1160\n");
    fflush(_coverage_fout);
    }
    if (num < 0L) {
      {
      fprintf(_coverage_fout, "1146\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "1141\n");
        fflush(_coverage_fout);
        }
        __p = buf;
        {
        fprintf(_coverage_fout, "1142\n");
        fflush(_coverage_fout);
        }
        __num = (unsigned long )(- num);
        {
        fprintf(_coverage_fout, "1143\n");
        fflush(_coverage_fout);
        }
        *__p = (char )'\000';
        {
        fprintf(_coverage_fout, "1144\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "1137\n");
          fflush(_coverage_fout);
          }
          __p --;
          {
          fprintf(_coverage_fout, "1138\n");
          fflush(_coverage_fout);
          }
          *__p = (char )((int )((char )(__num % 10UL)) + 48);
          {
          fprintf(_coverage_fout, "1139\n");
          fflush(_coverage_fout);
          }
          __num /= 10UL;
          {
          fprintf(_coverage_fout, "1140\n");
          fflush(_coverage_fout);
          }
          if (__num > 0UL) {
            {
            fprintf(_coverage_fout, "1136\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
        }
        {
        fprintf(_coverage_fout, "1145\n");
        fflush(_coverage_fout);
        }
        r = __p;
        break;
      }
      {
      fprintf(_coverage_fout, "1147\n");
      fflush(_coverage_fout);
      }
      r --;
      {
      fprintf(_coverage_fout, "1148\n");
      fflush(_coverage_fout);
      }
      *r = (char )'-';
    } else {
      {
      fprintf(_coverage_fout, "1159\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "1154\n");
        fflush(_coverage_fout);
        }
        __p___0 = buf;
        {
        fprintf(_coverage_fout, "1155\n");
        fflush(_coverage_fout);
        }
        __num___0 = (unsigned long )num;
        {
        fprintf(_coverage_fout, "1156\n");
        fflush(_coverage_fout);
        }
        *__p___0 = (char )'\000';
        {
        fprintf(_coverage_fout, "1157\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "1150\n");
          fflush(_coverage_fout);
          }
          __p___0 --;
          {
          fprintf(_coverage_fout, "1151\n");
          fflush(_coverage_fout);
          }
          *__p___0 = (char )((int )((char )(__num___0 % 10UL)) + 48);
          {
          fprintf(_coverage_fout, "1152\n");
          fflush(_coverage_fout);
          }
          __num___0 /= 10UL;
          {
          fprintf(_coverage_fout, "1153\n");
          fflush(_coverage_fout);
          }
          if (__num___0 > 0UL) {
            {
            fprintf(_coverage_fout, "1149\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
        }
        {
        fprintf(_coverage_fout, "1158\n");
        fflush(_coverage_fout);
        }
        r = __p___0;
        break;
      }
    }
    break;
  }
  {
  fprintf(_coverage_fout, "1162\n");
  fflush(_coverage_fout);
  }
  return (r);
}
}
__inline static char *smart_str_print_long(char *buf , long num ) ;
extern zend_module_entry libxml_module_entry ;
struct _xmlXPathParserContext;
typedef struct _xmlXPathParserContext xmlXPathParserContext;
typedef xmlXPathParserContext *xmlXPathParserContextPtr;
extern void xmlXPtrEvalRangePredicate(xmlXPathParserContextPtr ctxt ) ;
struct _xmlXPathObject;
typedef struct _xmlXPathObject xmlXPathObject;
typedef xmlXPathObject *xmlXPathObjectPtr;
extern xmlNodePtr xmlXPtrBuildNodeList(xmlXPathObjectPtr obj ) ;
extern void xmlXPtrRangeToFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
struct _xmlXPathContext;
typedef struct _xmlXPathContext xmlXPathContext;
typedef xmlXPathContext *xmlXPathContextPtr;
extern xmlXPathObjectPtr xmlXPtrEval(xmlChar const   *str ,
                                     xmlXPathContextPtr ctx ) ;
extern xmlXPathContextPtr xmlXPtrNewContext(xmlDocPtr doc , xmlNodePtr here ,
                                            xmlNodePtr origin ) ;
struct _xmlLocationSet;
typedef struct _xmlLocationSet xmlLocationSet;
typedef xmlLocationSet *xmlLocationSetPtr;
extern void xmlXPtrLocationSetRemove(xmlLocationSetPtr cur , int val ) ;
extern void xmlXPtrLocationSetDel(xmlLocationSetPtr cur , xmlXPathObjectPtr val ) ;
extern xmlXPathObjectPtr xmlXPtrWrapLocationSet(xmlLocationSetPtr val ) ;
extern void xmlXPtrLocationSetAdd(xmlLocationSetPtr cur , xmlXPathObjectPtr val ) ;
extern xmlXPathObjectPtr xmlXPtrNewCollapsedRange(xmlNodePtr start ) ;
extern xmlXPathObjectPtr xmlXPtrNewRangeNodeObject(xmlNodePtr start ,
                                                   xmlXPathObjectPtr end ) ;
struct _xmlNodeSet;
typedef struct _xmlNodeSet xmlNodeSet;
typedef xmlNodeSet *xmlNodeSetPtr;
extern xmlXPathObjectPtr xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set ) ;
extern xmlXPathObjectPtr xmlXPtrNewLocationSetNodes(xmlNodePtr start ,
                                                    xmlNodePtr end ) ;
extern xmlXPathObjectPtr xmlXPtrNewRangeNodes(xmlNodePtr start , xmlNodePtr end ) ;
extern xmlXPathObjectPtr xmlXPtrNewRangePointNode(xmlXPathObjectPtr start ,
                                                  xmlNodePtr end ) ;
extern xmlXPathObjectPtr xmlXPtrNewRangeNodePoint(xmlNodePtr start ,
                                                  xmlXPathObjectPtr end ) ;
extern xmlXPathObjectPtr xmlXPtrNewRangePoints(xmlXPathObjectPtr start ,
                                               xmlXPathObjectPtr end ) ;
extern xmlXPathObjectPtr xmlXPtrNewRange(xmlNodePtr start , int startindex ,
                                         xmlNodePtr end , int endindex ) ;
extern xmlLocationSetPtr xmlXPtrLocationSetMerge(xmlLocationSetPtr val1 ,
                                                 xmlLocationSetPtr val2 ) ;
extern void xmlXPtrFreeLocationSet(xmlLocationSetPtr obj ) ;
extern xmlLocationSetPtr xmlXPtrLocationSetCreate(xmlXPathObjectPtr val ) ;
extern void xmlXPathNodeSetFreeNs(xmlNsPtr ns ) ;
extern void xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathSumFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathLangFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathNotFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt ,
                                           int nargs ) ;
extern void xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt ,
                                            int nargs ) ;
extern void xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt ,
                                       int nargs ) ;
extern void xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt ,
                                         int nargs ) ;
extern void xmlXPathStringFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt ,
                                         int nargs ) ;
extern void xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathIdFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathCountFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern void xmlXPathLastFunction(xmlXPathParserContextPtr ctxt , int nargs ) ;
extern xmlNodePtr xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt ,
                                               xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt ,
                                       xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt ,
                                        xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt ,
                                        xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt ,
                                        xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt ,
                                        xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt ,
                                               xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt ,
                                             xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextParent(xmlXPathParserContextPtr ctxt ,
                                     xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt ,
                                               xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt ,
                                         xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextChild(xmlXPathParserContextPtr ctxt ,
                                    xmlNodePtr cur ) ;
extern xmlNodePtr xmlXPathNextSelf(xmlXPathParserContextPtr ctxt ,
                                   xmlNodePtr cur ) ;
extern int xmlXPathIsNodeType(xmlChar const   *name ) ;
extern void xmlXPathModValues(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathDivValues(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathMultValues(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathSubValues(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathAddValues(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt ) ;
extern int xmlXPathCompareValues(xmlXPathParserContextPtr ctxt , int inf ,
                                 int strict ) ;
extern int xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt ) ;
extern int xmlXPathEqualValues(xmlXPathParserContextPtr ctxt ) ;
extern xmlXPathObjectPtr xmlXPathWrapExternal(void *val ) ;
extern xmlXPathObjectPtr xmlXPathWrapNodeSet(xmlNodeSetPtr val ) ;
extern xmlXPathObjectPtr xmlXPathNewNodeSetList(xmlNodeSetPtr val ) ;
extern void xmlXPathNodeSetRemove(xmlNodeSetPtr cur , int val ) ;
extern void xmlXPathNodeSetDel(xmlNodeSetPtr cur , xmlNodePtr val ) ;
extern xmlNodeSetPtr xmlXPathNodeSetMerge(xmlNodeSetPtr val1 ,
                                          xmlNodeSetPtr val2 ) ;
extern void xmlXPathRegisterAllFunctions(xmlXPathContextPtr ctxt ) ;
extern int xmlXPathEvaluatePredicateResult(xmlXPathParserContextPtr ctxt ,
                                           xmlXPathObjectPtr res ) ;
extern double xmlXPathStringEvalNumber(xmlChar const   *str ) ;
extern xmlChar *xmlXPathParseNCName(xmlXPathParserContextPtr ctxt ) ;
extern xmlChar *xmlXPathParseName(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathEvalExpr(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathRoot(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathNodeSetSort(xmlNodeSetPtr set ) ;
extern void xmlXPathNodeSetAddNs(xmlNodeSetPtr cur , xmlNodePtr node ,
                                 xmlNsPtr ns ) ;
extern void xmlXPathNodeSetAddUnique(xmlNodeSetPtr cur , xmlNodePtr val ) ;
extern void xmlXPathNodeSetAdd(xmlNodeSetPtr cur , xmlNodePtr val ) ;
extern xmlXPathObjectPtr xmlXPathNewValueTree(xmlNodePtr val ) ;
extern xmlXPathObjectPtr xmlXPathNewNodeSet(xmlNodePtr val ) ;
extern xmlXPathObjectPtr xmlXPathNewBoolean(int val ) ;
extern xmlXPathObjectPtr xmlXPathNewFloat(double val ) ;
extern xmlXPathObjectPtr xmlXPathWrapCString(char *val ) ;
extern xmlXPathObjectPtr xmlXPathWrapString(xmlChar *val ) ;
extern xmlXPathObjectPtr xmlXPathNewCString(char const   *val ) ;
extern xmlXPathObjectPtr xmlXPathNewString(xmlChar const   *val ) ;
extern int valuePush(xmlXPathParserContextPtr ctxt , xmlXPathObjectPtr value ) ;
extern xmlXPathObjectPtr valuePop(xmlXPathParserContextPtr ctxt ) ;
extern void xmlXPathFreeParserContext(xmlXPathParserContextPtr ctxt ) ;
extern xmlXPathParserContextPtr xmlXPathNewParserContext(xmlChar const   *str ,
                                                         xmlXPathContextPtr ctxt ) ;
extern void xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt ) ;
extern xmlXPathObjectPtr xmlXPathVariableLookupNS(xmlXPathContextPtr ctxt ,
                                                  xmlChar const   *name ,
                                                  xmlChar const   *ns_uri ) ;
extern xmlXPathObjectPtr xmlXPathVariableLookup(xmlXPathContextPtr ctxt ,
                                                xmlChar const   *name ) ;
extern void xmlXPathRegisteredFuncsCleanup(xmlXPathContextPtr ctxt ) ;
typedef void (*xmlXPathFunction)(xmlXPathParserContextPtr ctxt , int nargs );
extern xmlXPathFunction xmlXPathFunctionLookupNS(xmlXPathContextPtr ctxt ,
                                                 xmlChar const   *name ,
                                                 xmlChar const   *ns_uri ) ;
extern xmlXPathFunction xmlXPathFunctionLookup(xmlXPathContextPtr ctxt ,
                                               xmlChar const   *name ) ;
extern int xmlXPathRegisterVariableNS(xmlXPathContextPtr ctxt ,
                                      xmlChar const   *name ,
                                      xmlChar const   *ns_uri ,
                                      xmlXPathObjectPtr value ) ;
extern int xmlXPathRegisterVariable(xmlXPathContextPtr ctxt ,
                                    xmlChar const   *name ,
                                    xmlXPathObjectPtr value ) ;
extern int xmlXPathRegisterFuncNS(xmlXPathContextPtr ctxt ,
                                  xmlChar const   *name ,
                                  xmlChar const   *ns_uri ,
                                  void (*f)(xmlXPathParserContextPtr ctxt ,
                                            int nargs ) ) ;
extern int xmlXPathRegisterFunc(xmlXPathContextPtr ctxt ,
                                xmlChar const   *name ,
                                void (*f)(xmlXPathParserContextPtr ctxt ,
                                          int nargs ) ) ;
extern void xmlXPathRegisteredNsCleanup(xmlXPathContextPtr ctxt ) ;
extern xmlChar const   *xmlXPathNsLookup(xmlXPathContextPtr ctxt ,
                                         xmlChar const   *prefix ) ;
extern int xmlXPathRegisterNs(xmlXPathContextPtr ctxt ,
                              xmlChar const   *prefix , xmlChar const   *ns_uri ) ;
extern xmlNodeSetPtr xmlXPathTrailing(xmlNodeSetPtr nodes1 ,
                                      xmlNodeSetPtr nodes2 ) ;
extern xmlNodeSetPtr xmlXPathNodeTrailing(xmlNodeSetPtr nodes , xmlNodePtr node ) ;
extern xmlNodeSetPtr xmlXPathTrailingSorted(xmlNodeSetPtr nodes1 ,
                                            xmlNodeSetPtr nodes2 ) ;
extern xmlNodeSetPtr xmlXPathNodeTrailingSorted(xmlNodeSetPtr nodes ,
                                                xmlNodePtr node ) ;
extern xmlNodeSetPtr xmlXPathLeading(xmlNodeSetPtr nodes1 ,
                                     xmlNodeSetPtr nodes2 ) ;
extern xmlNodeSetPtr xmlXPathNodeLeading(xmlNodeSetPtr nodes , xmlNodePtr node ) ;
extern xmlNodeSetPtr xmlXPathLeadingSorted(xmlNodeSetPtr nodes1 ,
                                           xmlNodeSetPtr nodes2 ) ;
extern xmlNodeSetPtr xmlXPathNodeLeadingSorted(xmlNodeSetPtr nodes ,
                                               xmlNodePtr node ) ;
extern int xmlXPathHasSameNodes(xmlNodeSetPtr nodes1 , xmlNodeSetPtr nodes2 ) ;
extern xmlNodeSetPtr xmlXPathDistinct(xmlNodeSetPtr nodes ) ;
extern xmlNodeSetPtr xmlXPathDistinctSorted(xmlNodeSetPtr nodes ) ;
extern xmlNodeSetPtr xmlXPathIntersection(xmlNodeSetPtr nodes1 ,
                                          xmlNodeSetPtr nodes2 ) ;
extern xmlNodeSetPtr xmlXPathDifference(xmlNodeSetPtr nodes1 ,
                                        xmlNodeSetPtr nodes2 ) ;
extern int xmlXPathNodeSetContains(xmlNodeSetPtr cur , xmlNodePtr val ) ;
struct _xmlXPathCompExpr;
typedef struct _xmlXPathCompExpr xmlXPathCompExpr;
typedef xmlXPathCompExpr *xmlXPathCompExprPtr;
extern void xmlXPathDebugDumpCompExpr(FILE *output , xmlXPathCompExprPtr comp ,
                                      int depth ) ;
extern void xmlXPathDebugDumpObject(FILE *output , xmlXPathObjectPtr cur ,
                                    int depth ) ;
extern void xmlXPathErr(xmlXPathParserContextPtr ctxt , int error ) ;
extern void xmlXPatherror(xmlXPathParserContextPtr ctxt , char const   *file ,
                          int line , int no ) ;
extern void xmlXPathRegisterFuncLookup(xmlXPathContextPtr ctxt ,
                                       xmlXPathFunction (*f)(void *ctxt ,
                                                             xmlChar const   *name ,
                                                             xmlChar const   *ns_uri ) ,
                                       void *funcCtxt ) ;
extern void xmlXPathRegisterVariableLookup(xmlXPathContextPtr ctxt ,
                                           xmlXPathObjectPtr (*f)(void *ctxt ,
                                                                  xmlChar const   *name ,
                                                                  xmlChar const   *ns_uri ) ,
                                           void *data ) ;
extern void *xmlXPathPopExternal(xmlXPathParserContextPtr ctxt ) ;
extern xmlNodeSetPtr xmlXPathPopNodeSet(xmlXPathParserContextPtr ctxt ) ;
extern xmlChar *xmlXPathPopString(xmlXPathParserContextPtr ctxt ) ;
extern double xmlXPathPopNumber(xmlXPathParserContextPtr ctxt ) ;
extern int xmlXPathPopBoolean(xmlXPathParserContextPtr ctxt ) ;
extern int htmlIsBooleanAttr(xmlChar const   *name ) ;
extern void htmlNodeDumpOutput(xmlOutputBufferPtr buf , xmlDocPtr doc ,
                               xmlNodePtr cur , char const   *encoding ) ;
extern void htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf ,
                                           xmlDocPtr cur ,
                                           char const   *encoding , int format ) ;
extern void htmlDocContentDumpOutput(xmlOutputBufferPtr buf , xmlDocPtr cur ,
                                     char const   *encoding ) ;
extern int htmlSaveFileEnc(char const   *filename , xmlDocPtr cur ,
                           char const   *encoding ) ;
extern int htmlNodeDumpFileFormat(FILE *out , xmlDocPtr doc , xmlNodePtr cur ,
                                  char const   *encoding , int format ) ;
extern void htmlNodeDumpFile(FILE *out , xmlDocPtr doc , xmlNodePtr cur ) ;
extern int htmlNodeDump(xmlBufferPtr buf , xmlDocPtr doc , xmlNodePtr cur ) ;
extern int htmlSaveFile(char const   *filename , xmlDocPtr cur ) ;
extern int htmlDocDump(FILE *f , xmlDocPtr cur ) ;
extern void htmlDocDumpMemory(xmlDocPtr cur , xmlChar **mem , int *size ) ;
extern int htmlSetMetaEncoding(htmlDocPtr doc , xmlChar const   *encoding ) ;
extern htmlDocPtr htmlNewDocNoDtD(xmlChar const   *URI ,
                                  xmlChar const   *ExternalID ) ;
extern htmlDocPtr htmlNewDoc(xmlChar const   *URI , xmlChar const   *ExternalID ) ;
extern int xmlC14NExecute(xmlDocPtr doc ,
                          int (*is_visible_callback)(void *user_data ,
                                                     xmlNodePtr node ,
                                                     xmlNodePtr parent ) ,
                          void *user_data , int mode ,
                          xmlChar **inclusive_ns_prefixes , int with_comments ,
                          xmlOutputBufferPtr buf ) ;
extern int xmlC14NDocSave(xmlDocPtr doc , xmlNodeSetPtr nodes , int mode ,
                          xmlChar **inclusive_ns_prefixes , int with_comments ,
                          char const   *filename , int compression ) ;
extern int xmlC14NDocDumpMemory(xmlDocPtr doc , xmlNodeSetPtr nodes , int mode ,
                                xmlChar **inclusive_ns_prefixes ,
                                int with_comments , xmlChar **doc_txt_ptr ) ;
extern int xmlC14NDocSaveTo(xmlDocPtr doc , xmlNodeSetPtr nodes , int mode ,
                            xmlChar **inclusive_ns_prefixes ,
                            int with_comments , xmlOutputBufferPtr buf ) ;
extern int xmlXPathIsInf(double val ) ;
extern int xmlXPathIsNaN(double val ) ;
extern void xmlXPathInit(void) ;
extern void xmlXPathFreeCompExpr(xmlXPathCompExprPtr comp ) ;
extern int xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp ,
                                         xmlXPathContextPtr ctxt ) ;
extern xmlXPathObjectPtr xmlXPathCompiledEval(xmlXPathCompExprPtr comp ,
                                              xmlXPathContextPtr ctx ) ;
extern xmlXPathCompExprPtr xmlXPathCtxtCompile(xmlXPathContextPtr ctxt ,
                                               xmlChar const   *str ) ;
extern xmlXPathCompExprPtr xmlXPathCompile(xmlChar const   *str ) ;
extern int xmlXPathEvalPredicate(xmlXPathContextPtr ctxt ,
                                 xmlXPathObjectPtr res ) ;
extern xmlXPathObjectPtr xmlXPathEvalExpression(xmlChar const   *str ,
                                                xmlXPathContextPtr ctxt ) ;
extern xmlXPathObjectPtr xmlXPathEval(xmlChar const   *str ,
                                      xmlXPathContextPtr ctx ) ;
extern long xmlXPathOrderDocElems(xmlDocPtr doc ) ;
extern int xmlXPathContextSetCache(xmlXPathContextPtr ctxt , int active ,
                                   int value , int options ) ;
extern void xmlXPathFreeContext(xmlXPathContextPtr ctxt ) ;
extern xmlXPathContextPtr xmlXPathNewContext(xmlDocPtr doc ) ;
extern xmlXPathObjectPtr xmlXPathConvertString(xmlXPathObjectPtr val ) ;
extern xmlXPathObjectPtr xmlXPathConvertNumber(xmlXPathObjectPtr val ) ;
extern xmlXPathObjectPtr xmlXPathConvertBoolean(xmlXPathObjectPtr val ) ;
extern xmlChar *xmlXPathCastToString(xmlXPathObjectPtr val ) ;
extern xmlChar *xmlXPathCastNodeSetToString(xmlNodeSetPtr ns ) ;
extern xmlChar *xmlXPathCastNodeToString(xmlNodePtr node ) ;
extern xmlChar *xmlXPathCastNumberToString(double val ) ;
extern xmlChar *xmlXPathCastBooleanToString(int val ) ;
extern double xmlXPathCastToNumber(xmlXPathObjectPtr val ) ;
extern double xmlXPathCastNodeSetToNumber(xmlNodeSetPtr ns ) ;
extern double xmlXPathCastNodeToNumber(xmlNodePtr node ) ;
extern double xmlXPathCastStringToNumber(xmlChar const   *val ) ;
extern double xmlXPathCastBooleanToNumber(int val ) ;
extern int xmlXPathCastToBoolean(xmlXPathObjectPtr val ) ;
extern int xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns ) ;
extern int xmlXPathCastStringToBoolean(xmlChar const   *val ) ;
extern int xmlXPathCastNumberToBoolean(double val ) ;
extern int xmlXPathCmpNodes(xmlNodePtr node1 , xmlNodePtr node2 ) ;
extern xmlXPathObjectPtr xmlXPathObjectCopy(xmlXPathObjectPtr val ) ;
extern void xmlXPathFreeNodeSet(xmlNodeSetPtr obj ) ;
extern void xmlXPathFreeNodeSetList(xmlXPathObjectPtr obj ) ;
extern xmlNodeSetPtr xmlXPathNodeSetCreate(xmlNodePtr val ) ;
extern void xmlXPathFreeObject(xmlXPathObjectPtr obj ) ;
extern double xmlXPathNINF ;
extern double xmlXPathPINF ;
extern double xmlXPathNAN ;
struct _xmlXIncludeCtxt;
typedef struct _xmlXIncludeCtxt xmlXIncludeCtxt;
typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr;
extern int xmlXIncludeProcessNode(xmlXIncludeCtxtPtr ctxt , xmlNodePtr tree ) ;
extern void xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt ) ;
extern int xmlXIncludeSetFlags(xmlXIncludeCtxtPtr ctxt , int flags ) ;
extern xmlXIncludeCtxtPtr xmlXIncludeNewContext(xmlDocPtr doc ) ;
extern int xmlXIncludeProcessTreeFlags(xmlNodePtr tree , int flags ) ;
extern int xmlXIncludeProcessTree(xmlNodePtr tree ) ;
extern int xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree , int flags ,
                                           void *data ) ;
extern int xmlXIncludeProcessFlagsData(xmlDocPtr doc , int flags , void *data ) ;
extern int xmlXIncludeProcess(xmlDocPtr doc ) ;
extern xmlChar *xmlPathToURI(xmlChar const   *path ) ;
extern xmlChar *xmlURIEscape(xmlChar const   *str ) ;
extern int xmlNormalizeURIPath(char *path ) ;
extern char *xmlURIUnescapeString(char const   *str , int len , char *target ) ;
extern void xmlPrintURI(FILE *stream , xmlURIPtr uri ) ;
extern xmlChar *xmlSaveUri(xmlURIPtr uri ) ;
extern xmlURIPtr xmlParseURIRaw(char const   *str , int raw ) ;
extern xmlURIPtr xmlParseURI(char const   *str ) ;
extern xmlChar *xmlBuildRelativeURI(xmlChar const   *URI ,
                                    xmlChar const   *base ) ;
extern xmlChar *xmlBuildURI(xmlChar const   *URI , xmlChar const   *base ) ;
extern void xmlHandleEntity(xmlParserCtxtPtr ctxt , xmlEntityPtr entity ) ;
extern xmlChar *xmlDecodeEntities(xmlParserCtxtPtr ctxt , int len , int what ,
                                  xmlChar end , xmlChar end2 , xmlChar end3 ) ;
extern xmlChar *xmlNamespaceParseQName(xmlParserCtxtPtr ctxt , xmlChar **prefix ) ;
extern void xmlParserHandleReference(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlNamespaceParseNCName(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlScanName(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlNamespaceParseNSDef(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseNamespace(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseQuotedString(xmlParserCtxtPtr ctxt ) ;
extern void xmlSetEntityReferenceFunc(void (*func)(xmlEntityPtr ent ,
                                                   xmlNodePtr firstNode ,
                                                   xmlNodePtr lastNode ) ) ;
extern void htmlInitAutoClose(void) ;
extern void xmlParserInputShrink(xmlParserInputPtr in ) ;
extern void xmlNextChar(xmlParserCtxtPtr ctxt ) ;
extern int xmlCopyChar(int len , xmlChar *out , int val ) ;
extern int xmlCopyCharMultiByte(xmlChar *out , int val ) ;
extern int xmlCurrentChar(xmlParserCtxtPtr ctxt , int *len ) ;
extern int xmlCheckLanguageID(xmlChar const   *lang ) ;
extern void xmlParserHandlePEReference(xmlParserCtxtPtr ctxt ) ;
extern int xmlStringCurrentChar(xmlParserCtxtPtr ctxt , xmlChar const   *cur ,
                                int *len ) ;
extern int xmlSkipBlankChars(xmlParserCtxtPtr ctxt ) ;
extern int namePush(xmlParserCtxtPtr ctxt , xmlChar const   *value ) ;
extern xmlChar const   *namePop(xmlParserCtxtPtr ctxt ) ;
extern xmlParserInputPtr inputPop(xmlParserCtxtPtr ctxt ) ;
extern int inputPush(xmlParserCtxtPtr ctxt , xmlParserInputPtr value ) ;
extern xmlNodePtr nodePop(xmlParserCtxtPtr ctxt ) ;
extern int nodePush(xmlParserCtxtPtr ctxt , xmlNodePtr value ) ;
extern xmlChar *xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt ,
                                           xmlChar const   *str , int len ,
                                           int what , xmlChar end ,
                                           xmlChar end2 , xmlChar end3 ) ;
extern xmlChar *xmlStringDecodeEntities(xmlParserCtxtPtr ctxt ,
                                        xmlChar const   *str , int what ,
                                        xmlChar end , xmlChar end2 ,
                                        xmlChar end3 ) ;
extern void xmlParseExternalSubset(xmlParserCtxtPtr ctxt ,
                                   xmlChar const   *ExternalID ,
                                   xmlChar const   *SystemID ) ;
extern void xmlParseMisc(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseTextDecl(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseXMLDecl(xmlParserCtxtPtr ctxt ) ;
extern int xmlParseSDDecl(xmlParserCtxtPtr ctxt ) ;
extern xmlChar const   *xmlParseEncodingDecl(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseEncName(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseVersionInfo(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseVersionNum(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseElement(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseContent(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseCDSect(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseEndTag(xmlParserCtxtPtr ctxt ) ;
extern xmlChar const   *xmlParseStartTag(xmlParserCtxtPtr ctxt ) ;
extern xmlChar const   *xmlParseAttribute(xmlParserCtxtPtr ctxt ,
                                          xmlChar **value ) ;
extern void xmlParseDocTypeDecl(xmlParserCtxtPtr ctxt ) ;
extern void xmlParsePEReference(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseReference(xmlParserCtxtPtr ctxt ) ;
extern xmlEntityPtr xmlParseEntityRef(xmlParserCtxtPtr ctxt ) ;
extern int xmlParseCharRef(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseMarkupDecl(xmlParserCtxtPtr ctxt ) ;
extern int xmlParseElementDecl(xmlParserCtxtPtr ctxt ) ;
extern int xmlParseElementContentDecl(xmlParserCtxtPtr ctxt ,
                                      xmlChar const   *name ,
                                      xmlElementContentPtr *result ) ;
extern xmlElementContentPtr xmlParseElementChildrenContentDecl(xmlParserCtxtPtr ctxt ,
                                                               int inputchk ) ;
extern xmlElementContentPtr xmlParseElementMixedContentDecl(xmlParserCtxtPtr ctxt ,
                                                            int inputchk ) ;
extern void xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt ) ;
extern int xmlParseAttributeType(xmlParserCtxtPtr ctxt ,
                                 xmlEnumerationPtr *tree ) ;
extern int xmlParseEnumeratedType(xmlParserCtxtPtr ctxt ,
                                  xmlEnumerationPtr *tree ) ;
extern xmlEnumerationPtr xmlParseEnumerationType(xmlParserCtxtPtr ctxt ) ;
extern xmlEnumerationPtr xmlParseNotationType(xmlParserCtxtPtr ctxt ) ;
extern int xmlParseDefaultDecl(xmlParserCtxtPtr ctxt , xmlChar **value ) ;
extern void xmlParseEntityDecl(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseNotationDecl(xmlParserCtxtPtr ctxt ) ;
extern void xmlParsePI(xmlParserCtxtPtr ctxt ) ;
extern xmlChar const   *xmlParsePITarget(xmlParserCtxtPtr ctxt ) ;
extern void xmlParseComment(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseExternalID(xmlParserCtxtPtr ctxt , xmlChar **publicID ,
                                   int strict ) ;
extern void xmlParseCharData(xmlParserCtxtPtr ctxt , int cdata ) ;
extern xmlChar *xmlParsePubidLiteral(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseSystemLiteral(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseAttValue(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlParseEntityValue(xmlParserCtxtPtr ctxt , xmlChar **orig ) ;
extern xmlChar *xmlParseNmtoken(xmlParserCtxtPtr ctxt ) ;
extern xmlChar const   *xmlParseName(xmlParserCtxtPtr ctxt ) ;
extern xmlChar *xmlSplitQName(xmlParserCtxtPtr ctxt , xmlChar const   *name ,
                              xmlChar **prefix ) ;
extern xmlParserInputPtr xmlNewInputStream(xmlParserCtxtPtr ctxt ) ;
extern xmlParserInputPtr xmlNewInputFromFile(xmlParserCtxtPtr ctxt ,
                                             char const   *filename ) ;
extern void xmlFreeInputStream(xmlParserInputPtr input ) ;
extern xmlChar xmlPopInput(xmlParserCtxtPtr ctxt ) ;
extern int xmlPushInput(xmlParserCtxtPtr ctxt , xmlParserInputPtr input ) ;
extern xmlParserInputPtr xmlNewEntityInputStream(xmlParserCtxtPtr ctxt ,
                                                 xmlEntityPtr entity ) ;
extern xmlParserInputPtr xmlNewStringInputStream(xmlParserCtxtPtr ctxt ,
                                                 xmlChar const   *buffer ) ;
extern int xmlSwitchInputEncoding(xmlParserCtxtPtr ctxt ,
                                  xmlParserInputPtr input ,
                                  xmlCharEncodingHandlerPtr handler ) ;
extern int xmlSwitchToEncoding(xmlParserCtxtPtr ctxt ,
                               xmlCharEncodingHandlerPtr handler ) ;
extern int xmlSwitchEncoding(xmlParserCtxtPtr ctxt , xmlCharEncoding enc ) ;
extern xmlParserCtxtPtr xmlCreateEntityParserCtxt(xmlChar const   *URL ,
                                                  xmlChar const   *ID ,
                                                  xmlChar const   *base ) ;
extern xmlParserCtxtPtr xmlCreateURLParserCtxt(char const   *filename ,
                                               int options ) ;
extern int xmlIsLetter(int c ) ;
extern xmlChar const   xmlStringComment[] ;
extern xmlChar const   xmlStringTextNoenc[] ;
extern xmlChar const   xmlStringText[] ;
extern unsigned int xmlParserMaxDepth ;
extern int xmlIsPubidChar(unsigned int ch ) ;
extern int xmlIsIdeographic(unsigned int ch ) ;
extern int xmlIsExtender(unsigned int ch ) ;
extern int xmlIsDigit(unsigned int ch ) ;
extern int xmlIsCombining(unsigned int ch ) ;
extern int xmlIsChar(unsigned int ch ) ;
extern int xmlIsBlank(unsigned int ch ) ;
extern int xmlIsBaseChar(unsigned int ch ) ;
extern unsigned char const   xmlIsPubidChar_tab[256] ;
struct _xmlChRangeGroup;
typedef struct _xmlChRangeGroup xmlChRangeGroup;
extern xmlChRangeGroup const   xmlIsIdeographicGroup ;
extern xmlChRangeGroup const   xmlIsExtenderGroup ;
extern xmlChRangeGroup const   xmlIsDigitGroup ;
extern xmlChRangeGroup const   xmlIsCombiningGroup ;
extern xmlChRangeGroup const   xmlIsCharGroup ;
extern xmlChRangeGroup const   xmlIsBaseCharGroup ;
extern int xmlCharInRange(unsigned int val , xmlChRangeGroup const   *group ) ;
typedef xmlNodePtr htmlNodePtr;
enum __anonenum_htmlStatus_102;
typedef enum __anonenum_htmlStatus_102 htmlStatus;
extern htmlStatus htmlNodeStatus(htmlNodePtr  , int  ) ;
struct _htmlElemDesc;
typedef struct _htmlElemDesc htmlElemDesc;
extern htmlStatus htmlElementStatusHere(htmlElemDesc const   * ,
                                        htmlElemDesc const   * ) ;
extern int htmlElementAllowedHere(htmlElemDesc const   * , xmlChar const   * ) ;
extern htmlStatus htmlAttrAllowed(htmlElemDesc const   * , xmlChar const   * ,
                                  int  ) ;
extern htmlDocPtr htmlCtxtReadIO(xmlParserCtxtPtr ctxt ,
                                 int (*ioread)(void *context , char *buffer ,
                                               int len ) ,
                                 int (*ioclose)(void *context ) , void *ioctx ,
                                 char const   *URL , char const   *encoding ,
                                 int options ) ;
extern htmlDocPtr htmlCtxtReadFd(xmlParserCtxtPtr ctxt , int fd ,
                                 char const   *URL , char const   *encoding ,
                                 int options ) ;
extern htmlDocPtr htmlCtxtReadMemory(xmlParserCtxtPtr ctxt ,
                                     char const   *buffer , int size ,
                                     char const   *URL ,
                                     char const   *encoding , int options ) ;
extern htmlDocPtr htmlCtxtReadFile(xmlParserCtxtPtr ctxt ,
                                   char const   *filename ,
                                   char const   *encoding , int options ) ;
extern htmlDocPtr htmlCtxtReadDoc(xmlParserCtxtPtr ctxt , xmlChar const   *cur ,
                                  char const   *URL , char const   *encoding ,
                                  int options ) ;
extern htmlDocPtr htmlReadIO(int (*ioread)(void *context , char *buffer ,
                                           int len ) ,
                             int (*ioclose)(void *context ) , void *ioctx ,
                             char const   *URL , char const   *encoding ,
                             int options ) ;
extern htmlDocPtr htmlReadFd(int fd , char const   *URL ,
                             char const   *encoding , int options ) ;
extern htmlDocPtr htmlReadMemory(char const   *buffer , int size ,
                                 char const   *URL , char const   *encoding ,
                                 int options ) ;
extern htmlDocPtr htmlReadFile(char const   *URL , char const   *encoding ,
                               int options ) ;
extern htmlDocPtr htmlReadDoc(xmlChar const   *cur , char const   *URL ,
                              char const   *encoding , int options ) ;
extern int htmlCtxtUseOptions(htmlParserCtxtPtr ctxt , int options ) ;
extern void htmlCtxtReset(htmlParserCtxtPtr ctxt ) ;
extern int htmlParseChunk(htmlParserCtxtPtr ctxt , char const   *chunk ,
                          int size , int terminate ) ;
typedef xmlSAXHandlerPtr htmlSAXHandlerPtr;
extern htmlParserCtxtPtr htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax ,
                                                  void *user_data ,
                                                  char const   *chunk ,
                                                  int size ,
                                                  char const   *filename ,
                                                  xmlCharEncoding enc ) ;
extern int htmlHandleOmittedElem(int val ) ;
extern int htmlIsScriptAttribute(xmlChar const   *name ) ;
extern int htmlEncodeEntities(unsigned char *out , int *outlen ,
                              unsigned char const   *in , int *inlen ,
                              int quoteChar ) ;
extern int UTF8ToHtml(unsigned char *out , int *outlen ,
                      unsigned char const   *in , int *inlen ) ;
extern htmlDocPtr htmlParseFile(char const   *filename , char const   *encoding ) ;
extern htmlDocPtr htmlSAXParseFile(char const   *filename ,
                                   char const   *encoding ,
                                   htmlSAXHandlerPtr sax , void *userData ) ;
extern htmlDocPtr htmlParseDoc(xmlChar *cur , char const   *encoding ) ;
extern htmlDocPtr htmlSAXParseDoc(xmlChar *cur , char const   *encoding ,
                                  htmlSAXHandlerPtr sax , void *userData ) ;
extern htmlParserCtxtPtr htmlNewParserCtxt(void) ;
extern void htmlParseElement(htmlParserCtxtPtr ctxt ) ;
extern int htmlParseCharRef(htmlParserCtxtPtr ctxt ) ;
struct _htmlEntityDesc;
typedef struct _htmlEntityDesc htmlEntityDesc;
extern htmlEntityDesc const   *htmlParseEntityRef(htmlParserCtxtPtr ctxt ,
                                                  xmlChar const   **str ) ;
extern int htmlAutoCloseTag(htmlDocPtr doc , xmlChar const   *name ,
                            htmlNodePtr elem ) ;
extern int htmlIsAutoClosed(htmlDocPtr doc , htmlNodePtr elem ) ;
extern htmlEntityDesc const   *htmlEntityValueLookup(unsigned int value ) ;
extern htmlEntityDesc const   *htmlEntityLookup(xmlChar const   *name ) ;
extern htmlElemDesc const   *htmlTagLookup(xmlChar const   *tag ) ;
enum __anonenum_xmlFeature_100;
typedef enum __anonenum_xmlFeature_100 xmlFeature;
extern int xmlHasFeature(xmlFeature feature ) ;
extern xmlDocPtr xmlCtxtReadIO(xmlParserCtxtPtr ctxt ,
                               int (*ioread)(void *context , char *buffer ,
                                             int len ) ,
                               int (*ioclose)(void *context ) , void *ioctx ,
                               char const   *URL , char const   *encoding ,
                               int options ) ;
extern xmlDocPtr xmlCtxtReadFd(xmlParserCtxtPtr ctxt , int fd ,
                               char const   *URL , char const   *encoding ,
                               int options ) ;
extern xmlDocPtr xmlCtxtReadMemory(xmlParserCtxtPtr ctxt ,
                                   char const   *buffer , int size ,
                                   char const   *URL , char const   *encoding ,
                                   int options ) ;
extern xmlDocPtr xmlCtxtReadFile(xmlParserCtxtPtr ctxt ,
                                 char const   *filename ,
                                 char const   *encoding , int options ) ;
extern xmlDocPtr xmlCtxtReadDoc(xmlParserCtxtPtr ctxt , xmlChar const   *cur ,
                                char const   *URL , char const   *encoding ,
                                int options ) ;
extern xmlDocPtr xmlReadIO(int (*ioread)(void *context , char *buffer , int len ) ,
                           int (*ioclose)(void *context ) , void *ioctx ,
                           char const   *URL , char const   *encoding ,
                           int options ) ;
extern xmlDocPtr xmlReadFd(int fd , char const   *URL , char const   *encoding ,
                           int options ) ;
extern xmlDocPtr xmlReadMemory(char const   *buffer , int size ,
                               char const   *URL , char const   *encoding ,
                               int options ) ;
extern xmlDocPtr xmlReadFile(char const   *URL , char const   *encoding ,
                             int options ) ;
extern xmlDocPtr xmlReadDoc(xmlChar const   *cur , char const   *URL ,
                            char const   *encoding , int options ) ;
extern int xmlCtxtResetPush(xmlParserCtxtPtr ctxt , char const   *chunk ,
                            int size , char const   *filename ,
                            char const   *encoding ) ;
extern void xmlCtxtReset(xmlParserCtxtPtr ctxt ) ;
extern long xmlByteConsumed(xmlParserCtxtPtr ctxt ) ;
extern xmlParserInputPtr xmlLoadExternalEntity(char const   *URL ,
                                               char const   *ID ,
                                               xmlParserCtxtPtr ctxt ) ;
typedef xmlParserInputPtr (*xmlExternalEntityLoader)(char const   *URL ,
                                                     char const   *ID ,
                                                     xmlParserCtxtPtr context );
extern xmlExternalEntityLoader xmlGetExternalEntityLoader(void) ;
extern void xmlSetExternalEntityLoader(xmlParserInputPtr (*f)(char const   *URL ,
                                                              char const   *ID ,
                                                              xmlParserCtxtPtr context ) ) ;
typedef xmlParserNodeInfo *xmlParserNodeInfoPtr;
extern void xmlParserAddNodeInfo(xmlParserCtxtPtr ctxt ,
                                 xmlParserNodeInfoPtr info ) ;
struct _xmlParserNodeInfoSeq;
typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr;
extern unsigned long xmlParserFindNodeInfoIndex(xmlParserNodeInfoSeqPtr seq ,
                                                xmlNodePtr node ) ;
extern void xmlClearNodeInfoSeq(xmlParserNodeInfoSeqPtr seq ) ;
extern void xmlInitNodeInfoSeq(xmlParserNodeInfoSeqPtr seq ) ;
extern xmlParserNodeInfo const   *xmlParserFindNodeInfo(xmlParserCtxtPtr ctxt ,
                                                        xmlNodePtr node ) ;
extern xmlParserInputPtr xmlNewIOInputStream(xmlParserCtxtPtr ctxt ,
                                             xmlParserInputBufferPtr input ,
                                             xmlCharEncoding enc ) ;
extern xmlParserCtxtPtr xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax ,
                                              void *user_data ,
                                              int (*ioread)(void *context ,
                                                            char *buffer ,
                                                            int len ) ,
                                              int (*ioclose)(void *context ) ,
                                              void *ioctx , xmlCharEncoding enc ) ;
extern int xmlParseChunk(xmlParserCtxtPtr ctxt , char const   *chunk ,
                         int size , int terminate ) ;
extern xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax ,
                                                void *user_data ,
                                                char const   *chunk , int size ,
                                                char const   *filename ) ;
extern int xmlSetFeature(xmlParserCtxtPtr ctxt , char const   *name ,
                         void *value ) ;
extern int xmlGetFeature(xmlParserCtxtPtr ctxt , char const   *name ,
                         void *result ) ;
extern int xmlGetFeaturesList(int *len , char const   **result ) ;
extern xmlParserCtxtPtr xmlCreateDocParserCtxt(xmlChar const   *cur ) ;
extern void xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt ,
                                    xmlChar const   *buffer ,
                                    char const   *filename ) ;
extern void xmlClearParserCtxt(xmlParserCtxtPtr ctxt ) ;
extern int xmlInitParserCtxt(xmlParserCtxtPtr ctxt ) ;
extern xmlParserCtxtPtr xmlNewParserCtxt(void) ;
extern int xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx ,
                                      xmlChar const   *URL ,
                                      xmlChar const   *ID , xmlNodePtr *lst ) ;
extern int xmlParseExternalEntity(xmlDocPtr doc , xmlSAXHandlerPtr sax ,
                                  void *user_data , int depth ,
                                  xmlChar const   *URL , xmlChar const   *ID ,
                                  xmlNodePtr *lst ) ;
extern int xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc ,
                                              xmlSAXHandlerPtr sax ,
                                              void *user_data , int depth ,
                                              xmlChar const   *string ,
                                              xmlNodePtr *lst , int recover ) ;
enum __anonenum_xmlParserErrors_91;
typedef enum __anonenum_xmlParserErrors_91 xmlParserErrors;
extern xmlParserErrors xmlParseInNodeContext(xmlNodePtr node ,
                                             char const   *data , int datalen ,
                                             int options , xmlNodePtr *lst ) ;
extern int xmlParseBalancedChunkMemory(xmlDocPtr doc , xmlSAXHandlerPtr sax ,
                                       void *user_data , int depth ,
                                       xmlChar const   *string ,
                                       xmlNodePtr *lst ) ;
extern xmlDtdPtr xmlIOParseDTD(xmlSAXHandlerPtr sax ,
                               xmlParserInputBufferPtr input ,
                               xmlCharEncoding enc ) ;
extern xmlDtdPtr xmlParseDTD(xmlChar const   *ExternalID ,
                             xmlChar const   *SystemID ) ;
extern xmlDtdPtr xmlSAXParseDTD(xmlSAXHandlerPtr sax ,
                                xmlChar const   *ExternalID ,
                                xmlChar const   *SystemID ) ;
extern xmlDocPtr xmlParseEntity(char const   *filename ) ;
extern xmlDocPtr xmlSAXParseEntity(xmlSAXHandlerPtr sax ,
                                   char const   *filename ) ;
extern xmlDocPtr xmlSAXParseFileWithData(xmlSAXHandlerPtr sax ,
                                         char const   *filename , int recovery ,
                                         void *data ) ;
extern xmlDocPtr xmlSAXParseFile(xmlSAXHandlerPtr sax , char const   *filename ,
                                 int recovery ) ;
extern xmlDocPtr xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax ,
                                           char const   *buffer , int size ,
                                           int recovery , void *data ) ;
extern xmlDocPtr xmlSAXParseMemory(xmlSAXHandlerPtr sax , char const   *buffer ,
                                   int size , int recovery ) ;
extern xmlDocPtr xmlSAXParseDoc(xmlSAXHandlerPtr sax , xmlChar const   *cur ,
                                int recovery ) ;
extern int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax , void *user_data ,
                                 char const   *buffer , int size ) ;
extern int xmlSAXUserParseFile(xmlSAXHandlerPtr sax , void *user_data ,
                               char const   *filename ) ;
extern int xmlParseExtParsedEnt(xmlParserCtxtPtr ctxt ) ;
extern xmlDocPtr xmlRecoverFile(char const   *filename ) ;
extern xmlDocPtr xmlRecoverMemory(char const   *buffer , int size ) ;
extern xmlDocPtr xmlRecoverDoc(xmlChar const   *cur ) ;
extern int xmlLineNumbersDefault(int val ) ;
extern int xmlPedanticParserDefault(int val ) ;
extern void xmlStopParser(xmlParserCtxtPtr ctxt ) ;
extern int xmlKeepBlanksDefault(int val ) ;
extern int xmlSubstituteEntitiesDefault(int val ) ;
extern xmlDocPtr xmlParseMemory(char const   *buffer , int size ) ;
extern xmlDocPtr xmlParseFile(char const   *filename ) ;
extern xmlDocPtr xmlParseDoc(xmlChar const   *cur ) ;
extern int xmlParserInputGrow(xmlParserInputPtr in , int len ) ;
extern int xmlParserInputRead(xmlParserInputPtr in , int len ) ;
extern void xmlCleanupParser(void) ;
extern int xmlIOFTPClose(void *context ) ;
extern int xmlIOFTPRead(void *context , char *buffer , int len ) ;
extern void *xmlIOFTPOpen(char const   *filename ) ;
extern int xmlIOFTPMatch(char const   *filename ) ;
extern int xmlIOHTTPClose(void *context ) ;
extern int xmlIOHTTPRead(void *context , char *buffer , int len ) ;
extern void *xmlIOHTTPOpenW(char const   *post_uri , int compression ) ;
extern void *xmlIOHTTPOpen(char const   *filename ) ;
extern int xmlIOHTTPMatch(char const   *filename ) ;
extern int xmlFileClose(void *context ) ;
extern int xmlFileRead(void *context , char *buffer , int len ) ;
extern void *xmlFileOpen(char const   *filename ) ;
extern int xmlFileMatch(char const   *filename ) ;
extern int xmlCheckFilename(char const   *path ) ;
extern xmlChar *xmlNormalizeWindowsPath(xmlChar const   *path ) ;
extern xmlParserInputPtr xmlNoNetExternalEntityLoader(char const   *URL ,
                                                      char const   *ID ,
                                                      xmlParserCtxtPtr ctxt ) ;
extern xmlParserInputPtr xmlCheckHTTPInput(xmlParserCtxtPtr ctxt ,
                                           xmlParserInputPtr ret ) ;
extern void xmlRegisterHTTPPostCallbacks(void) ;
extern xmlOutputBufferPtr __xmlOutputBufferCreateFilename(char const   *URI ,
                                                          xmlCharEncodingHandlerPtr encoder ,
                                                          int compression ) ;
extern int xmlRegisterOutputCallbacks(int (*matchFunc)(char const   *filename ) ,
                                      void *(*openFunc)(char const   *filename ) ,
                                      int (*writeFunc)(void *context ,
                                                       char const   *buffer ,
                                                       int len ) ,
                                      int (*closeFunc)(void *context ) ) ;
extern int xmlOutputBufferClose(xmlOutputBufferPtr out ) ;
extern int xmlOutputBufferFlush(xmlOutputBufferPtr out ) ;
extern int xmlOutputBufferWriteEscape(xmlOutputBufferPtr out ,
                                      xmlChar const   *str ,
                                      int (*escaping)(unsigned char *out ,
                                                      int *outlen ,
                                                      unsigned char const   *in ,
                                                      int *inlen ) ) ;
extern int xmlOutputBufferWriteString(xmlOutputBufferPtr out ,
                                      char const   *str ) ;
extern int xmlOutputBufferWrite(xmlOutputBufferPtr out , int len ,
                                char const   *buf ) ;
extern xmlOutputBufferPtr xmlOutputBufferCreateIO(int (*iowrite)(void *context ,
                                                                 char const   *buffer ,
                                                                 int len ) ,
                                                  int (*ioclose)(void *context ) ,
                                                  void *ioctx ,
                                                  xmlCharEncodingHandlerPtr encoder ) ;
extern xmlOutputBufferPtr xmlOutputBufferCreateFd(int fd ,
                                                  xmlCharEncodingHandlerPtr encoder ) ;
extern xmlOutputBufferPtr xmlOutputBufferCreateBuffer(xmlBufferPtr buffer ,
                                                      xmlCharEncodingHandlerPtr encoder ) ;
extern xmlOutputBufferPtr xmlOutputBufferCreateFile(FILE *file ,
                                                    xmlCharEncodingHandlerPtr encoder ) ;
extern xmlOutputBufferPtr xmlOutputBufferCreateFilename(char const   *URI ,
                                                        xmlCharEncodingHandlerPtr encoder ,
                                                        int compression ) ;
extern xmlOutputBufferPtr xmlAllocOutputBuffer(xmlCharEncodingHandlerPtr encoder ) ;
extern void xmlRegisterDefaultOutputCallbacks(void) ;
extern void xmlCleanupOutputCallbacks(void) ;
extern xmlParserInputBufferPtr __xmlParserInputBufferCreateFilename(char const   *URI ,
                                                                    xmlCharEncoding enc ) ;
extern int xmlRegisterInputCallbacks(int (*matchFunc)(char const   *filename ) ,
                                     void *(*openFunc)(char const   *filename ) ,
                                     int (*readFunc)(void *context ,
                                                     char *buffer , int len ) ,
                                     int (*closeFunc)(void *context ) ) ;
extern char *xmlParserGetDirectory(char const   *filename ) ;
extern void xmlFreeParserInputBuffer(xmlParserInputBufferPtr in ) ;
extern int xmlParserInputBufferPush(xmlParserInputBufferPtr in , int len ,
                                    char const   *buf ) ;
extern int xmlParserInputBufferGrow(xmlParserInputBufferPtr in , int len ) ;
extern int xmlParserInputBufferRead(xmlParserInputBufferPtr in , int len ) ;
extern xmlParserInputBufferPtr xmlParserInputBufferCreateIO(int (*ioread)(void *context ,
                                                                          char *buffer ,
                                                                          int len ) ,
                                                            int (*ioclose)(void *context ) ,
                                                            void *ioctx ,
                                                            xmlCharEncoding enc ) ;
extern xmlParserInputBufferPtr xmlParserInputBufferCreateStatic(char const   *mem ,
                                                                int size ,
                                                                xmlCharEncoding enc ) ;
extern xmlParserInputBufferPtr xmlParserInputBufferCreateMem(char const   *mem ,
                                                             int size ,
                                                             xmlCharEncoding enc ) ;
extern xmlParserInputBufferPtr xmlParserInputBufferCreateFd(int fd ,
                                                            xmlCharEncoding enc ) ;
extern xmlParserInputBufferPtr xmlParserInputBufferCreateFile(FILE *file ,
                                                              xmlCharEncoding enc ) ;
extern xmlParserInputBufferPtr xmlParserInputBufferCreateFilename(char const   *URI ,
                                                                  xmlCharEncoding enc ) ;
extern xmlParserInputBufferPtr xmlAllocParserInputBuffer(xmlCharEncoding enc ) ;
extern void xmlRegisterDefaultInputCallbacks(void) ;
extern int xmlPopInputCallbacks(void) ;
extern void xmlCleanupInputCallbacks(void) ;
typedef xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameFunc)(char const   *URI ,
                                                                xmlCharEncodingHandlerPtr encoder ,
                                                                int compression );
extern xmlOutputBufferCreateFilenameFunc *__xmlOutputBufferCreateFilenameValue(void) ;
typedef xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameFunc)(char const   *URI ,
                                                                          xmlCharEncoding enc );
extern xmlParserInputBufferCreateFilenameFunc *__xmlParserInputBufferCreateFilenameValue(void) ;
typedef void (*xmlDeregisterNodeFunc)(xmlNodePtr node );
extern xmlDeregisterNodeFunc *__xmlDeregisterNodeDefaultValue(void) ;
typedef void (*xmlRegisterNodeFunc)(xmlNodePtr node );
extern xmlRegisterNodeFunc *__xmlRegisterNodeDefaultValue(void) ;
extern int xmlThrDefSubstituteEntitiesDefaultValue(int v ) ;
extern int *__xmlSubstituteEntitiesDefaultValue(void) ;
extern int xmlThrDefSaveNoEmptyTags(int v ) ;
extern int xmlThrDefPedanticParserDefaultValue(int v ) ;
extern int *__xmlPedanticParserDefaultValue(void) ;
extern char const   **__xmlParserVersion(void) ;
extern int xmlThrDefParserDebugEntities(int v ) ;
extern int *__xmlParserDebugEntities(void) ;
extern int xmlThrDefLoadExtDtdDefaultValue(int v ) ;
extern int *__xmlLoadExtDtdDefaultValue(void) ;
extern int xmlThrDefLineNumbersDefaultValue(int v ) ;
extern int *__xmlLineNumbersDefaultValue(void) ;
extern int xmlThrDefKeepBlanksDefaultValue(int v ) ;
extern int *__xmlKeepBlanksDefaultValue(void) ;
extern char const   *xmlThrDefTreeIndentString(char const   *v ) ;
extern char const   **__xmlTreeIndentString(void) ;
extern int xmlThrDefIndentTreeOutput(int v ) ;
extern int *__xmlIndentTreeOutput(void) ;
extern int xmlThrDefGetWarningsDefaultValue(int v ) ;
extern int *__xmlGetWarningsDefaultValue(void) ;
extern void **__xmlStructuredErrorContext(void) ;
extern void **__xmlGenericErrorContext(void) ;
typedef void (*xmlStructuredErrorFunc)(void *userData , xmlErrorPtr error );
extern xmlStructuredErrorFunc *__xmlStructuredError(void) ;
typedef void ( /* format attribute */  (*xmlGenericErrorFunc))(void *ctx ,
                                                               char const   *msg 
                                                               , ...);
extern xmlGenericErrorFunc *__xmlGenericError(void) ;
extern int xmlThrDefDoValidityCheckingDefaultValue(int v ) ;
extern int *__xmlDoValidityCheckingDefaultValue(void) ;
extern xmlSAXLocator *__xmlDefaultSAXLocator(void) ;
struct _xmlSAXHandlerV1;
typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1;
extern xmlSAXHandlerV1 *__xmlDefaultSAXHandler(void) ;
extern int xmlThrDefDefaultBufferSize(int v ) ;
extern int *__xmlDefaultBufferSize(void) ;
enum __anonenum_xmlBufferAllocationScheme_80;
typedef enum __anonenum_xmlBufferAllocationScheme_80 xmlBufferAllocationScheme;
extern xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v ) ;
extern xmlBufferAllocationScheme *__xmlBufferAllocScheme(void) ;
extern int *__oldXMLWDcompatibility(void) ;
extern xmlError *__xmlLastError(void) ;
extern xmlSAXHandlerV1 *__htmlDefaultSAXHandler(void) ;
extern xmlSAXHandlerV1 *__docbDefaultSAXHandler(void) ;
extern char *(*xmlMemStrdup)(char const   *str ) ;
extern void *(*xmlRealloc)(void *mem , size_t size ) ;
extern void *( __attribute__((__alloc_size__(1))) (*xmlMallocAtomic))(size_t size ) ;
extern void *( __attribute__((__alloc_size__(1))) (*xmlMalloc))(size_t size ) ;
extern xmlParserInputBufferCreateFilenameFunc xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferPtr (*func)(char const   *URI ,
                                                                                                                              xmlCharEncoding enc ) ) ;
extern xmlOutputBufferCreateFilenameFunc xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferPtr (*func)(char const   *URI ,
                                                                                                               xmlCharEncodingHandlerPtr encoder ,
                                                                                                               int compression ) ) ;
extern xmlDeregisterNodeFunc xmlThrDefDeregisterNodeDefault(void (*func)(xmlNodePtr node ) ) ;
extern xmlDeregisterNodeFunc xmlDeregisterNodeDefault(void (*func)(xmlNodePtr node ) ) ;
extern xmlRegisterNodeFunc xmlThrDefRegisterNodeDefault(void (*func)(xmlNodePtr node ) ) ;
extern xmlRegisterNodeFunc xmlRegisterNodeDefault(void (*func)(xmlNodePtr node ) ) ;
extern void xmlThrDefSetStructuredErrorFunc(void *ctx ,
                                            void (*handler)(void *userData ,
                                                            xmlErrorPtr error ) ) ;
extern void xmlThrDefSetGenericErrorFunc(void *ctx ,
                                         void ( /* format attribute */  (*handler))(void *ctx ,
                                                                                    char const   *msg 
                                                                                    , ...) ) ;
struct _xmlGlobalState;
typedef struct _xmlGlobalState xmlGlobalState;
typedef xmlGlobalState *xmlGlobalStatePtr;
extern void xmlInitializeGlobalState(xmlGlobalStatePtr gs ) ;
extern xmlGlobalStatePtr xmlGetGlobalState(void) ;
extern void xmlCleanupThreads(void) ;
extern int xmlIsMainThread(void) ;
extern int xmlGetThreadId(void) ;
extern void xmlUnlockLibrary(void) ;
extern void xmlLockLibrary(void) ;
extern void xmlInitThreads(void) ;
struct _xmlRMutex;
typedef struct _xmlRMutex xmlRMutex;
typedef xmlRMutex *xmlRMutexPtr;
extern void xmlFreeRMutex(xmlRMutexPtr tok ) ;
extern void xmlRMutexUnlock(xmlRMutexPtr tok ) ;
extern void xmlRMutexLock(xmlRMutexPtr tok ) ;
extern xmlRMutexPtr xmlNewRMutex(void) ;
struct _xmlMutex;
typedef struct _xmlMutex xmlMutex;
typedef xmlMutex *xmlMutexPtr;
extern void xmlFreeMutex(xmlMutexPtr tok ) ;
extern void xmlMutexUnlock(xmlMutexPtr tok ) ;
extern void xmlMutexLock(xmlMutexPtr tok ) ;
extern xmlMutexPtr xmlNewMutex(void) ;
extern xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameDefault(xmlOutputBufferPtr (*func)(char const   *URI ,
                                                                                                         xmlCharEncodingHandlerPtr encoder ,
                                                                                                         int compression ) ) ;
extern xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameDefault(xmlParserInputBufferPtr (*func)(char const   *URI ,
                                                                                                                        xmlCharEncoding enc ) ) ;
extern void xmlCleanupGlobals(void) ;
extern void xmlInitGlobals(void) ;
extern char *xmlMemStrdupLoc(char const   *str , char const   *file , int line ) ;
extern void *xmlMallocAtomicLoc(size_t size , char const   *file , int line )  __attribute__((__alloc_size__(1))) ;
extern void *xmlReallocLoc(void *ptr , size_t size , char const   *file ,
                           int line ) ;
extern void *xmlMallocLoc(size_t size , char const   *file , int line )  __attribute__((__alloc_size__(1))) ;
extern char *xmlMemoryStrdup(char const   *str ) ;
extern void xmlMemFree(void *ptr ) ;
extern void *xmlMemRealloc(void *ptr , size_t size ) ;
extern void *xmlMemMalloc(size_t size )  __attribute__((__alloc_size__(1))) ;
extern void xmlMemoryDump(void) ;
extern void xmlMemShow(FILE *fp , int nr ) ;
extern void xmlMemDisplayLast(FILE *fp , long nbBytes ) ;
extern void xmlMemDisplay(FILE *fp ) ;
extern int xmlMemBlocks(void) ;
extern int xmlMemUsed(void) ;
extern void xmlCleanupMemory(void) ;
extern int xmlInitMemory(void) ;
typedef char *(*xmlStrdupFunc)(char const   *str );
typedef void *(*xmlReallocFunc)(void *mem , size_t size );
typedef void *( __attribute__((__alloc_size__(1))) (*xmlMallocFunc))(size_t size );
typedef void (*xmlFreeFunc)(void *mem );
extern int xmlGcMemGet(xmlFreeFunc *freeFunc , xmlMallocFunc *mallocFunc ,
                       xmlMallocFunc *mallocAtomicFunc ,
                       xmlReallocFunc *reallocFunc , xmlStrdupFunc *strdupFunc ) ;
extern int xmlGcMemSetup(void (*freeFunc)(void *mem ) ,
                         void *( __attribute__((__alloc_size__(1))) (*mallocFunc))(size_t size ) ,
                         void *( __attribute__((__alloc_size__(1))) (*mallocAtomicFunc))(size_t size ) ,
                         void *(*reallocFunc)(void *mem , size_t size ) ,
                         char *(*strdupFunc)(char const   *str ) ) ;
extern int xmlMemGet(xmlFreeFunc *freeFunc , xmlMallocFunc *mallocFunc ,
                     xmlReallocFunc *reallocFunc , xmlStrdupFunc *strdupFunc ) ;
extern int xmlMemSetup(void (*freeFunc)(void *mem ) ,
                       void *( __attribute__((__alloc_size__(1))) (*mallocFunc))(size_t size ) ,
                       void *(*reallocFunc)(void *mem , size_t size ) ,
                       char *(*strdupFunc)(char const   *str ) ) ;
extern void xmlDefaultSAXHandlerInit(void) ;
extern void docbDefaultSAXHandlerInit(void) ;
extern void xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr ) ;
extern void htmlDefaultSAXHandlerInit(void) ;
extern void xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr ) ;
extern void xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr , int warning ) ;
extern int xmlSAXVersion(xmlSAXHandler *hdlr , int version ) ;
extern int xmlSAXDefaultVersion(int version ) ;
extern void xmlSAX2CDataBlock(void *ctx , xmlChar const   *value , int len ) ;
extern void xmlSAX2Comment(void *ctx , xmlChar const   *value ) ;
extern void xmlSAX2ProcessingInstruction(void *ctx , xmlChar const   *target ,
                                         xmlChar const   *data ) ;
extern void xmlSAX2IgnorableWhitespace(void *ctx , xmlChar const   *ch ,
                                       int len ) ;
extern void xmlSAX2Characters(void *ctx , xmlChar const   *ch , int len ) ;
extern void xmlSAX2Reference(void *ctx , xmlChar const   *name ) ;
extern void xmlSAX2EndElementNs(void *ctx , xmlChar const   *localname ,
                                xmlChar const   *prefix , xmlChar const   *URI ) ;
extern void xmlSAX2StartElementNs(void *ctx , xmlChar const   *localname ,
                                  xmlChar const   *prefix ,
                                  xmlChar const   *URI , int nb_namespaces ,
                                  xmlChar const   **namespaces ,
                                  int nb_attributes , int nb_defaulted ,
                                  xmlChar const   **attributes ) ;
extern void xmlSAX2EndElement(void *ctx , xmlChar const   *name ) ;
extern void xmlSAX2StartElement(void *ctx , xmlChar const   *fullname ,
                                xmlChar const   **atts ) ;
extern void xmlSAX2EndDocument(void *ctx ) ;
extern void xmlSAX2StartDocument(void *ctx ) ;
extern void xmlSAX2UnparsedEntityDecl(void *ctx , xmlChar const   *name ,
                                      xmlChar const   *publicId ,
                                      xmlChar const   *systemId ,
                                      xmlChar const   *notationName ) ;
extern void xmlSAX2NotationDecl(void *ctx , xmlChar const   *name ,
                                xmlChar const   *publicId ,
                                xmlChar const   *systemId ) ;
extern void xmlSAX2ElementDecl(void *ctx , xmlChar const   *name , int type ,
                               xmlElementContentPtr content ) ;
extern void xmlSAX2AttributeDecl(void *ctx , xmlChar const   *elem ,
                                 xmlChar const   *fullname , int type ,
                                 int def , xmlChar const   *defaultValue ,
                                 xmlEnumerationPtr tree ) ;
extern void xmlSAX2EntityDecl(void *ctx , xmlChar const   *name , int type ,
                              xmlChar const   *publicId ,
                              xmlChar const   *systemId , xmlChar *content ) ;
extern xmlParserInputPtr xmlSAX2ResolveEntity(void *ctx ,
                                              xmlChar const   *publicId ,
                                              xmlChar const   *systemId ) ;
extern xmlEntityPtr xmlSAX2GetParameterEntity(void *ctx , xmlChar const   *name ) ;
extern xmlEntityPtr xmlSAX2GetEntity(void *ctx , xmlChar const   *name ) ;
extern void xmlSAX2ExternalSubset(void *ctx , xmlChar const   *name ,
                                  xmlChar const   *ExternalID ,
                                  xmlChar const   *SystemID ) ;
extern void xmlSAX2InternalSubset(void *ctx , xmlChar const   *name ,
                                  xmlChar const   *ExternalID ,
                                  xmlChar const   *SystemID ) ;
extern int xmlSAX2HasExternalSubset(void *ctx ) ;
extern int xmlSAX2HasInternalSubset(void *ctx ) ;
extern int xmlSAX2IsStandalone(void *ctx ) ;
extern int xmlSAX2GetColumnNumber(void *ctx ) ;
extern int xmlSAX2GetLineNumber(void *ctx ) ;
extern void xmlSAX2SetDocumentLocator(void *ctx , xmlSAXLocatorPtr loc ) ;
extern xmlChar const   *xmlSAX2GetSystemId(void *ctx ) ;
extern xmlChar const   *xmlSAX2GetPublicId(void *ctx ) ;
extern void initdocbDefaultSAXHandler(xmlSAXHandlerV1 *hdlr ) ;
extern void inithtmlDefaultSAXHandler(xmlSAXHandlerV1 *hdlr ) ;
extern void initxmlDefaultSAXHandler(xmlSAXHandlerV1 *hdlr , int warning ) ;
extern void cdataBlock(void *ctx , xmlChar const   *value , int len ) ;
extern void comment(void *ctx , xmlChar const   *value ) ;
extern void namespaceDecl(void *ctx , xmlChar const   *href ,
                          xmlChar const   *prefix ) ;
extern int checkNamespace(void *ctx , xmlChar *nameSpace ) ;
extern xmlNsPtr getNamespace(void *ctx ) ;
extern void setNamespace(void *ctx , xmlChar const   *name ) ;
extern void globalNamespace(void *ctx , xmlChar const   *href ,
                            xmlChar const   *prefix ) ;
extern void processingInstruction(void *ctx , xmlChar const   *target ,
                                  xmlChar const   *data ) ;
extern void ignorableWhitespace(void *ctx , xmlChar const   *ch , int len ) ;
extern void characters(void *ctx , xmlChar const   *ch , int len ) ;
extern void reference(void *ctx , xmlChar const   *name ) ;
extern void endElement(void *ctx , xmlChar const   *name ) ;
extern void startElement(void *ctx , xmlChar const   *fullname ,
                         xmlChar const   **atts ) ;
extern void attribute(void *ctx , xmlChar const   *fullname ,
                      xmlChar const   *value ) ;
extern void endDocument(void *ctx ) ;
extern void startDocument(void *ctx ) ;
extern void unparsedEntityDecl(void *ctx , xmlChar const   *name ,
                               xmlChar const   *publicId ,
                               xmlChar const   *systemId ,
                               xmlChar const   *notationName ) ;
extern void notationDecl(void *ctx , xmlChar const   *name ,
                         xmlChar const   *publicId , xmlChar const   *systemId ) ;
extern void elementDecl(void *ctx , xmlChar const   *name , int type ,
                        xmlElementContentPtr content ) ;
extern void attributeDecl(void *ctx , xmlChar const   *elem ,
                          xmlChar const   *fullname , int type , int def ,
                          xmlChar const   *defaultValue ,
                          xmlEnumerationPtr tree ) ;
extern void entityDecl(void *ctx , xmlChar const   *name , int type ,
                       xmlChar const   *publicId , xmlChar const   *systemId ,
                       xmlChar *content ) ;
extern xmlParserInputPtr resolveEntity(void *ctx , xmlChar const   *publicId ,
                                       xmlChar const   *systemId ) ;
extern xmlEntityPtr getParameterEntity(void *ctx , xmlChar const   *name ) ;
extern xmlEntityPtr getEntity(void *ctx , xmlChar const   *name ) ;
extern void externalSubset(void *ctx , xmlChar const   *name ,
                           xmlChar const   *ExternalID ,
                           xmlChar const   *SystemID ) ;
extern void internalSubset(void *ctx , xmlChar const   *name ,
                           xmlChar const   *ExternalID ,
                           xmlChar const   *SystemID ) ;
extern int hasExternalSubset(void *ctx ) ;
extern int hasInternalSubset(void *ctx ) ;
extern int isStandalone(void *ctx ) ;
extern int getColumnNumber(void *ctx ) ;
extern int getLineNumber(void *ctx ) ;
extern void setDocumentLocator(void *ctx , xmlSAXLocatorPtr loc ) ;
extern xmlChar const   *getSystemId(void *ctx ) ;
extern xmlChar const   *getPublicId(void *ctx ) ;
enum __anonenum_xlinkType_96;
typedef enum __anonenum_xlinkType_96 xlinkType;
extern xlinkType xlinkIsLink(xmlDocPtr doc , xmlNodePtr node ) ;
struct _xlinkHandler;
typedef struct _xlinkHandler xlinkHandler;
typedef xlinkHandler *xlinkHandlerPtr;
extern void xlinkSetDefaultHandler(xlinkHandlerPtr handler ) ;
extern xlinkHandlerPtr xlinkGetDefaultHandler(void) ;
extern void xlinkSetDefaultDetect(void (*func)(void *ctx , xmlNodePtr node ) ) ;
typedef void (*xlinkNodeDetectFunc)(void *ctx , xmlNodePtr node );
extern xlinkNodeDetectFunc xlinkGetDefaultDetect(void) ;
extern int isolat1ToUTF8(unsigned char *out , int *outlen ,
                         unsigned char const   *in , int *inlen ) ;
extern int UTF8Toisolat1(unsigned char *out , int *outlen ,
                         unsigned char const   *in , int *inlen ) ;
extern int xmlCharEncFirstLine(xmlCharEncodingHandler *handler ,
                               xmlBufferPtr out , xmlBufferPtr in ) ;
extern int xmlCharEncInFunc(xmlCharEncodingHandler *handler , xmlBufferPtr out ,
                            xmlBufferPtr in ) ;
extern int xmlCharEncOutFunc(xmlCharEncodingHandler *handler ,
                             xmlBufferPtr out , xmlBufferPtr in ) ;
extern xmlCharEncoding xmlDetectCharEncoding(unsigned char const   *in ,
                                             int len ) ;
extern char const   *xmlGetCharEncodingName(xmlCharEncoding enc ) ;
extern xmlCharEncoding xmlParseCharEncoding(char const   *name ) ;
extern void xmlCleanupEncodingAliases(void) ;
extern char const   *xmlGetEncodingAlias(char const   *alias ) ;
extern int xmlDelEncodingAlias(char const   *alias ) ;
extern int xmlAddEncodingAlias(char const   *name , char const   *alias ) ;
extern xmlCharEncodingHandlerPtr xmlNewCharEncodingHandler(char const   *name ,
                                                           int (*input)(unsigned char *out ,
                                                                        int *outlen ,
                                                                        unsigned char const   *in ,
                                                                        int *inlen ) ,
                                                           int (*output)(unsigned char *out ,
                                                                         int *outlen ,
                                                                         unsigned char const   *in ,
                                                                         int *inlen ) ) ;
extern xmlCharEncodingHandlerPtr xmlGetCharEncodingHandler(xmlCharEncoding enc ) ;
extern void xmlRegisterCharEncodingHandler(xmlCharEncodingHandlerPtr handler ) ;
extern void xmlCleanupCharEncodingHandlers(void) ;
extern void xmlInitCharEncodingHandlers(void) ;
typedef void *iconv_t;
extern int iconv_close(iconv_t __cd ) ;
extern size_t iconv(iconv_t __cd , char ** __restrict  __inbuf ,
                    size_t * __restrict  __inbytesleft ,
                    char ** __restrict  __outbuf ,
                    size_t * __restrict  __outbytesleft ) ;
extern iconv_t iconv_open(char const   *__tocode , char const   *__fromcode ) ;
extern void xmlCleanupPredefinedEntities(void) ;
extern void xmlDumpEntityDecl(xmlBufferPtr buf , xmlEntityPtr ent ) ;
typedef struct _xmlHashTable xmlEntitiesTable;
typedef xmlEntitiesTable *xmlEntitiesTablePtr;
extern void xmlDumpEntitiesTable(xmlBufferPtr buf , xmlEntitiesTablePtr table ) ;
extern void xmlFreeEntitiesTable(xmlEntitiesTablePtr table ) ;
extern xmlEntitiesTablePtr xmlCopyEntitiesTable(xmlEntitiesTablePtr table ) ;
extern xmlEntitiesTablePtr xmlCreateEntitiesTable(void) ;
extern xmlChar *xmlEncodeSpecialChars(xmlDocPtr doc , xmlChar const   *input ) ;
extern xmlChar *xmlEncodeEntitiesReentrant(xmlDocPtr doc ,
                                           xmlChar const   *input ) ;
extern xmlChar const   *xmlEncodeEntities(xmlDocPtr doc ,
                                          xmlChar const   *input ) ;
extern xmlEntityPtr xmlGetParameterEntity(xmlDocPtr doc , xmlChar const   *name ) ;
extern xmlEntityPtr xmlGetDtdEntity(xmlDocPtr doc , xmlChar const   *name ) ;
extern xmlEntityPtr xmlGetDocEntity(xmlDocPtr doc , xmlChar const   *name ) ;
extern xmlEntityPtr xmlGetPredefinedEntity(xmlChar const   *name ) ;
extern xmlEntityPtr xmlAddDtdEntity(xmlDocPtr doc , xmlChar const   *name ,
                                    int type , xmlChar const   *ExternalID ,
                                    xmlChar const   *SystemID ,
                                    xmlChar const   *content ) ;
extern xmlEntityPtr xmlAddDocEntity(xmlDocPtr doc , xmlChar const   *name ,
                                    int type , xmlChar const   *ExternalID ,
                                    xmlChar const   *SystemID ,
                                    xmlChar const   *content ) ;
extern xmlEntityPtr xmlNewEntity(xmlDocPtr doc , xmlChar const   *name ,
                                 int type , xmlChar const   *ExternalID ,
                                 xmlChar const   *SystemID ,
                                 xmlChar const   *content ) ;
extern void xmlInitializePredefinedEntities(void) ;
extern int xmlValidatePopElement(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                 xmlNodePtr elem , xmlChar const   *qname ) ;
extern int xmlValidatePushCData(xmlValidCtxtPtr ctxt , xmlChar const   *data ,
                                int len ) ;
extern int xmlValidatePushElement(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                  xmlNodePtr elem , xmlChar const   *qname ) ;
struct _xmlElement;
typedef struct _xmlElement xmlElement;
typedef xmlElement *xmlElementPtr;
extern int xmlValidBuildContentModel(xmlValidCtxtPtr ctxt , xmlElementPtr elem ) ;
extern int xmlValidateNmtokensValue(xmlChar const   *value ) ;
extern int xmlValidateNmtokenValue(xmlChar const   *value ) ;
extern int xmlValidateNamesValue(xmlChar const   *value ) ;
extern int xmlValidateNameValue(xmlChar const   *value ) ;
extern int xmlValidGetValidElements(xmlNode *prev , xmlNode *next ,
                                    xmlChar const   **names , int max ) ;
extern int xmlValidGetPotentialChildren(xmlElementContent *ctree ,
                                        xmlChar const   **names , int *len ,
                                        int max ) ;
extern xmlElementPtr xmlGetDtdElementDesc(xmlDtdPtr dtd , xmlChar const   *name ) ;
extern xmlElementPtr xmlGetDtdQElementDesc(xmlDtdPtr dtd ,
                                           xmlChar const   *name ,
                                           xmlChar const   *prefix ) ;
struct _xmlNotation;
typedef struct _xmlNotation xmlNotation;
typedef xmlNotation *xmlNotationPtr;
extern xmlNotationPtr xmlGetDtdNotationDesc(xmlDtdPtr dtd ,
                                            xmlChar const   *name ) ;
struct _xmlAttribute;
typedef struct _xmlAttribute xmlAttribute;
typedef xmlAttribute *xmlAttributePtr;
extern xmlAttributePtr xmlGetDtdQAttrDesc(xmlDtdPtr dtd ,
                                          xmlChar const   *elem ,
                                          xmlChar const   *name ,
                                          xmlChar const   *prefix ) ;
extern xmlAttributePtr xmlGetDtdAttrDesc(xmlDtdPtr dtd , xmlChar const   *elem ,
                                         xmlChar const   *name ) ;
extern int xmlIsMixedElement(xmlDocPtr doc , xmlChar const   *name ) ;
extern int xmlValidateNotationUse(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                  xmlChar const   *notationName ) ;
extern int xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt , xmlDocPtr doc ) ;
extern int xmlValidateOneNamespace(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                   xmlNodePtr elem , xmlChar const   *prefix ,
                                   xmlNsPtr ns , xmlChar const   *value ) ;
extern int xmlValidateOneAttribute(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                   xmlNodePtr elem , xmlAttrPtr attr ,
                                   xmlChar const   *value ) ;
extern int xmlValidateOneElement(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                 xmlNodePtr elem ) ;
extern int xmlValidateElement(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                              xmlNodePtr elem ) ;
extern int xmlValidateDtdFinal(xmlValidCtxtPtr ctxt , xmlDocPtr doc ) ;
extern int xmlValidateDtd(xmlValidCtxtPtr ctxt , xmlDocPtr doc , xmlDtdPtr dtd ) ;
extern int xmlValidateNotationDecl(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                   xmlNotationPtr nota ) ;
enum __anonenum_xmlAttributeType_82;
extern int xmlValidateAttributeValue(xmlAttributeType type ,
                                     xmlChar const   *value ) ;
extern int xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                    xmlAttributePtr attr ) ;
extern xmlChar *xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt ,
                                                    xmlDocPtr doc ,
                                                    xmlNodePtr elem ,
                                                    xmlChar const   *name ,
                                                    xmlChar const   *value ) ;
extern xmlChar *xmlValidNormalizeAttributeValue(xmlDocPtr doc ,
                                                xmlNodePtr elem ,
                                                xmlChar const   *name ,
                                                xmlChar const   *value ) ;
extern int xmlValidateElementDecl(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                                  xmlElementPtr elem ) ;
extern int xmlValidateRoot(xmlValidCtxtPtr ctxt , xmlDocPtr doc ) ;
struct _xmlList;
typedef struct _xmlList xmlList;
typedef xmlList *xmlListPtr;
extern xmlListPtr xmlGetRefs(xmlDocPtr doc , xmlChar const   *ID ) ;
extern int xmlRemoveRef(xmlDocPtr doc , xmlAttrPtr attr ) ;
extern int xmlIsRef(xmlDocPtr doc , xmlNodePtr elem , xmlAttrPtr attr ) ;
typedef struct _xmlHashTable xmlRefTable;
typedef xmlRefTable *xmlRefTablePtr;
extern void xmlFreeRefTable(xmlRefTablePtr table ) ;
struct _xmlRef;
typedef struct _xmlRef xmlRef;
typedef xmlRef *xmlRefPtr;
extern xmlRefPtr xmlAddRef(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                           xmlChar const   *value , xmlAttrPtr attr ) ;
extern int xmlRemoveID(xmlDocPtr doc , xmlAttrPtr attr ) ;
extern int xmlIsID(xmlDocPtr doc , xmlNodePtr elem , xmlAttrPtr attr ) ;
typedef struct _xmlHashTable xmlIDTable;
typedef xmlIDTable *xmlIDTablePtr;
extern void xmlFreeIDTable(xmlIDTablePtr table ) ;
struct _xmlID;
typedef struct _xmlID xmlID;
typedef xmlID *xmlIDPtr;
extern xmlIDPtr xmlAddID(xmlValidCtxtPtr ctxt , xmlDocPtr doc ,
                         xmlChar const   *value , xmlAttrPtr attr ) ;
extern void xmlDumpAttributeDecl(xmlBufferPtr buf , xmlAttributePtr attr ) ;
typedef struct _xmlHashTable xmlAttributeTable;
typedef xmlAttributeTable *xmlAttributeTablePtr;
extern void xmlDumpAttributeTable(xmlBufferPtr buf , xmlAttributeTablePtr table ) ;
extern void xmlFreeAttributeTable(xmlAttributeTablePtr table ) ;
extern xmlAttributeTablePtr xmlCopyAttributeTable(xmlAttributeTablePtr table ) ;
enum __anonenum_xmlAttributeDefault_83;
typedef enum __anonenum_xmlAttributeDefault_83 xmlAttributeDefault;
extern xmlAttributePtr xmlAddAttributeDecl(xmlValidCtxtPtr ctxt ,
                                           xmlDtdPtr dtd ,
                                           xmlChar const   *elem ,
                                           xmlChar const   *name ,
                                           xmlChar const   *ns ,
                                           xmlAttributeType type ,
                                           xmlAttributeDefault def ,
                                           xmlChar const   *defaultValue ,
                                           xmlEnumerationPtr tree ) ;
extern xmlEnumerationPtr xmlCopyEnumeration(xmlEnumerationPtr cur ) ;
extern void xmlFreeEnumeration(xmlEnumerationPtr cur ) ;
extern xmlEnumerationPtr xmlCreateEnumeration(xmlChar const   *name ) ;
extern void xmlDumpElementDecl(xmlBufferPtr buf , xmlElementPtr elem ) ;
typedef struct _xmlHashTable xmlElementTable;
typedef xmlElementTable *xmlElementTablePtr;
extern void xmlDumpElementTable(xmlBufferPtr buf , xmlElementTablePtr table ) ;
extern void xmlFreeElementTable(xmlElementTablePtr table ) ;
extern xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr table ) ;
enum __anonenum_xmlElementTypeVal_86;
typedef enum __anonenum_xmlElementTypeVal_86 xmlElementTypeVal;
extern xmlElementPtr xmlAddElementDecl(xmlValidCtxtPtr ctxt , xmlDtdPtr dtd ,
                                       xmlChar const   *name ,
                                       xmlElementTypeVal type ,
                                       xmlElementContentPtr content ) ;
extern void xmlSprintfElementContent(char *buf , xmlElementContentPtr content ,
                                     int englob ) ;
extern void xmlSnprintfElementContent(char *buf , int size ,
                                      xmlElementContentPtr content , int englob ) ;
extern void xmlFreeDocElementContent(xmlDocPtr doc , xmlElementContentPtr cur ) ;
extern xmlElementContentPtr xmlCopyDocElementContent(xmlDocPtr doc ,
                                                     xmlElementContentPtr content ) ;
enum __anonenum_xmlElementContentType_84;
typedef enum __anonenum_xmlElementContentType_84 xmlElementContentType;
extern xmlElementContentPtr xmlNewDocElementContent(xmlDocPtr doc ,
                                                    xmlChar const   *name ,
                                                    xmlElementContentType type ) ;
extern void xmlFreeElementContent(xmlElementContentPtr cur ) ;
extern xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content ) ;
extern xmlElementContentPtr xmlNewElementContent(xmlChar const   *name ,
                                                 xmlElementContentType type ) ;
typedef struct _xmlHashTable xmlNotationTable;
typedef xmlNotationTable *xmlNotationTablePtr;
extern void xmlDumpNotationTable(xmlBufferPtr buf , xmlNotationTablePtr table ) ;
extern void xmlDumpNotationDecl(xmlBufferPtr buf , xmlNotationPtr nota ) ;
extern void xmlFreeNotationTable(xmlNotationTablePtr table ) ;
extern xmlNotationTablePtr xmlCopyNotationTable(xmlNotationTablePtr table ) ;
extern xmlNotationPtr xmlAddNotationDecl(xmlValidCtxtPtr ctxt , xmlDtdPtr dtd ,
                                         xmlChar const   *name ,
                                         xmlChar const   *PublicID ,
                                         xmlChar const   *SystemID ) ;
extern int xmlAutomataIsDeterminist(xmlAutomataPtr am ) ;
struct _xmlRegexp;
typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp *xmlRegexpPtr;
extern xmlRegexpPtr xmlAutomataCompile(xmlAutomataPtr am ) ;
extern int xmlAutomataNewCounter(xmlAutomataPtr am , int min , int max ) ;
extern xmlAutomataStatePtr xmlAutomataNewCounterTrans(xmlAutomataPtr am ,
                                                      xmlAutomataStatePtr from ,
                                                      xmlAutomataStatePtr to ,
                                                      int counter ) ;
extern xmlAutomataStatePtr xmlAutomataNewCountedTrans(xmlAutomataPtr am ,
                                                      xmlAutomataStatePtr from ,
                                                      xmlAutomataStatePtr to ,
                                                      int counter ) ;
extern xmlAutomataStatePtr xmlAutomataNewEpsilon(xmlAutomataPtr am ,
                                                 xmlAutomataStatePtr from ,
                                                 xmlAutomataStatePtr to ) ;
extern xmlAutomataStatePtr xmlAutomataNewAllTrans(xmlAutomataPtr am ,
                                                  xmlAutomataStatePtr from ,
                                                  xmlAutomataStatePtr to ,
                                                  int lax ) ;
extern xmlAutomataStatePtr xmlAutomataNewOnceTrans2(xmlAutomataPtr am ,
                                                    xmlAutomataStatePtr from ,
                                                    xmlAutomataStatePtr to ,
                                                    xmlChar const   *token ,
                                                    xmlChar const   *token2 ,
                                                    int min , int max ,
                                                    void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewOnceTrans(xmlAutomataPtr am ,
                                                   xmlAutomataStatePtr from ,
                                                   xmlAutomataStatePtr to ,
                                                   xmlChar const   *token ,
                                                   int min , int max ,
                                                   void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewCountTrans2(xmlAutomataPtr am ,
                                                     xmlAutomataStatePtr from ,
                                                     xmlAutomataStatePtr to ,
                                                     xmlChar const   *token ,
                                                     xmlChar const   *token2 ,
                                                     int min , int max ,
                                                     void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewCountTrans(xmlAutomataPtr am ,
                                                    xmlAutomataStatePtr from ,
                                                    xmlAutomataStatePtr to ,
                                                    xmlChar const   *token ,
                                                    int min , int max ,
                                                    void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewNegTrans(xmlAutomataPtr am ,
                                                  xmlAutomataStatePtr from ,
                                                  xmlAutomataStatePtr to ,
                                                  xmlChar const   *token ,
                                                  xmlChar const   *token2 ,
                                                  void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewTransition2(xmlAutomataPtr am ,
                                                     xmlAutomataStatePtr from ,
                                                     xmlAutomataStatePtr to ,
                                                     xmlChar const   *token ,
                                                     xmlChar const   *token2 ,
                                                     void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewTransition(xmlAutomataPtr am ,
                                                    xmlAutomataStatePtr from ,
                                                    xmlAutomataStatePtr to ,
                                                    xmlChar const   *token ,
                                                    void *data ) ;
extern xmlAutomataStatePtr xmlAutomataNewState(xmlAutomataPtr am ) ;
extern int xmlAutomataSetFinalState(xmlAutomataPtr am ,
                                    xmlAutomataStatePtr state ) ;
extern xmlAutomataStatePtr xmlAutomataGetInitState(xmlAutomataPtr am ) ;
extern void xmlFreeAutomata(xmlAutomataPtr am ) ;
extern xmlAutomataPtr xmlNewAutomata(void) ;
struct _xmlLink;
typedef struct _xmlLink xmlLink;
typedef xmlLink *xmlLinkPtr;
extern void *xmlLinkGetData(xmlLinkPtr lk ) ;
extern int xmlListCopy(xmlListPtr cur , xmlListPtr old ) ;
extern xmlListPtr xmlListDup(xmlListPtr old ) ;
extern void xmlListMerge(xmlListPtr l1 , xmlListPtr l2 ) ;
extern void xmlListReverseWalk(xmlListPtr l ,
                               int (*walker)(void const   *data ,
                                             void const   *user ) ,
                               void const   *user ) ;
extern void xmlListWalk(xmlListPtr l , int (*walker)(void const   *data ,
                                                     void const   *user ) ,
                        void const   *user ) ;
extern void xmlListSort(xmlListPtr l ) ;
extern void xmlListReverse(xmlListPtr l ) ;
extern int xmlListPushBack(xmlListPtr l , void *data ) ;
extern int xmlListPushFront(xmlListPtr l , void *data ) ;
extern void xmlListPopBack(xmlListPtr l ) ;
extern void xmlListPopFront(xmlListPtr l ) ;
extern int xmlListSize(xmlListPtr l ) ;
extern xmlLinkPtr xmlListEnd(xmlListPtr l ) ;
extern xmlLinkPtr xmlListFront(xmlListPtr l ) ;
extern int xmlListEmpty(xmlListPtr l ) ;
extern void xmlListClear(xmlListPtr l ) ;
extern int xmlListRemoveAll(xmlListPtr l , void *data ) ;
extern int xmlListRemoveLast(xmlListPtr l , void *data ) ;
extern int xmlListRemoveFirst(xmlListPtr l , void *data ) ;
extern int xmlListAppend(xmlListPtr l , void *data ) ;
extern int xmlListInsert(xmlListPtr l , void *data ) ;
extern void *xmlListReverseSearch(xmlListPtr l , void *data ) ;
extern void *xmlListSearch(xmlListPtr l , void *data ) ;
extern void xmlListDelete(xmlListPtr l ) ;
extern xmlListPtr xmlListCreate(void (*deallocator)(xmlLinkPtr lk ) ,
                                int (*compare)(void const   *data0 ,
                                               void const   *data1 ) ) ;
extern int xmlCopyError(xmlErrorPtr from , xmlErrorPtr to ) ;
extern void xmlResetError(xmlErrorPtr err ) ;
extern void xmlCtxtResetLastError(void *ctx ) ;
extern xmlErrorPtr xmlCtxtGetLastError(void *ctx ) ;
extern void xmlResetLastError(void) ;
extern xmlErrorPtr xmlGetLastError(void) ;
extern void xmlParserPrintFileContext(xmlParserInputPtr input ) ;
extern void xmlParserPrintFileInfo(xmlParserInputPtr input ) ;
extern void ( /* format attribute */  xmlParserValidityWarning)(void *ctx ,
                                                                char const   *msg 
                                                                , ...) ;
extern void ( /* format attribute */  xmlParserValidityError)(void *ctx ,
                                                              char const   *msg 
                                                              , ...) ;
extern void ( /* format attribute */  xmlParserWarning)(void *ctx ,
                                                        char const   *msg  , ...) ;
extern void ( /* format attribute */  xmlParserError)(void *ctx ,
                                                      char const   *msg  , ...) ;
extern void xmlSetStructuredErrorFunc(void *ctx ,
                                      void (*handler)(void *userData ,
                                                      xmlErrorPtr error ) ) ;
extern void initGenericErrorDefaultFunc(xmlGenericErrorFunc *handler ) ;
extern void xmlSetGenericErrorFunc(void *ctx ,
                                   void ( /* format attribute */  (*handler))(void *ctx ,
                                                                              char const   *msg 
                                                                              , ...) ) ;
extern void xmlHashScanFull3(xmlHashTablePtr table , xmlChar const   *name ,
                             xmlChar const   *name2 , xmlChar const   *name3 ,
                             void (*f)(void *payload , void *data ,
                                       xmlChar const   *name ,
                                       xmlChar const   *name2 ,
                                       xmlChar const   *name3 ) , void *data ) ;
extern void xmlHashScanFull(xmlHashTablePtr table ,
                            void (*f)(void *payload , void *data ,
                                      xmlChar const   *name ,
                                      xmlChar const   *name2 ,
                                      xmlChar const   *name3 ) , void *data ) ;
extern void xmlHashScan3(xmlHashTablePtr table , xmlChar const   *name ,
                         xmlChar const   *name2 , xmlChar const   *name3 ,
                         void (*f)(void *payload , void *data , xmlChar *name ) ,
                         void *data ) ;
extern void xmlHashScan(xmlHashTablePtr table ,
                        void (*f)(void *payload , void *data , xmlChar *name ) ,
                        void *data ) ;
extern int xmlHashSize(xmlHashTablePtr table ) ;
extern xmlHashTablePtr xmlHashCopy(xmlHashTablePtr table ,
                                   void *(*f)(void *payload , xmlChar *name ) ) ;
extern void *xmlHashQLookup3(xmlHashTablePtr table , xmlChar const   *name ,
                             xmlChar const   *prefix , xmlChar const   *name2 ,
                             xmlChar const   *prefix2 , xmlChar const   *name3 ,
                             xmlChar const   *prefix3 ) ;
extern void *xmlHashQLookup2(xmlHashTablePtr table , xmlChar const   *name ,
                             xmlChar const   *prefix , xmlChar const   *name2 ,
                             xmlChar const   *prefix2 ) ;
extern void *xmlHashQLookup(xmlHashTablePtr table , xmlChar const   *name ,
                            xmlChar const   *prefix ) ;
extern void *xmlHashLookup3(xmlHashTablePtr table , xmlChar const   *name ,
                            xmlChar const   *name2 , xmlChar const   *name3 ) ;
extern void *xmlHashLookup2(xmlHashTablePtr table , xmlChar const   *name ,
                            xmlChar const   *name2 ) ;
extern void *xmlHashLookup(xmlHashTablePtr table , xmlChar const   *name ) ;
extern int xmlHashRemoveEntry3(xmlHashTablePtr table , xmlChar const   *name ,
                               xmlChar const   *name2 , xmlChar const   *name3 ,
                               void (*f)(void *payload , xmlChar *name ) ) ;
extern int xmlHashRemoveEntry2(xmlHashTablePtr table , xmlChar const   *name ,
                               xmlChar const   *name2 ,
                               void (*f)(void *payload , xmlChar *name ) ) ;
extern int xmlHashRemoveEntry(xmlHashTablePtr table , xmlChar const   *name ,
                              void (*f)(void *payload , xmlChar *name ) ) ;
extern int xmlHashUpdateEntry3(xmlHashTablePtr table , xmlChar const   *name ,
                               xmlChar const   *name2 , xmlChar const   *name3 ,
                               void *userdata ,
                               void (*f)(void *payload , xmlChar *name ) ) ;
extern int xmlHashAddEntry3(xmlHashTablePtr table , xmlChar const   *name ,
                            xmlChar const   *name2 , xmlChar const   *name3 ,
                            void *userdata ) ;
extern int xmlHashUpdateEntry2(xmlHashTablePtr table , xmlChar const   *name ,
                               xmlChar const   *name2 , void *userdata ,
                               void (*f)(void *payload , xmlChar *name ) ) ;
extern int xmlHashAddEntry2(xmlHashTablePtr table , xmlChar const   *name ,
                            xmlChar const   *name2 , void *userdata ) ;
extern int xmlHashUpdateEntry(xmlHashTablePtr table , xmlChar const   *name ,
                              void *userdata ,
                              void (*f)(void *payload , xmlChar *name ) ) ;
extern int xmlHashAddEntry(xmlHashTablePtr table , xmlChar const   *name ,
                           void *userdata ) ;
extern void xmlHashFree(xmlHashTablePtr table ,
                        void (*f)(void *payload , xmlChar *name ) ) ;
extern xmlHashTablePtr xmlHashCreateDict(int size , xmlDictPtr dict ) ;
extern xmlHashTablePtr xmlHashCreate(int size ) ;
extern xmlNodePtr xmlPreviousElementSibling(xmlNodePtr node ) ;
extern xmlNodePtr xmlLastElementChild(xmlNodePtr parent ) ;
extern xmlNodePtr xmlFirstElementChild(xmlNodePtr parent ) ;
extern xmlNodePtr xmlNextElementSibling(xmlNodePtr node ) ;
extern unsigned long xmlChildElementCount(xmlNodePtr parent ) ;
struct _xmlDOMWrapCtxt;
typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
extern int xmlDOMWrapCloneNode(xmlDOMWrapCtxtPtr ctxt , xmlDocPtr sourceDoc ,
                               xmlNodePtr node , xmlNodePtr *clonedNode ,
                               xmlDocPtr destDoc , xmlNodePtr destParent ,
                               int deep , int options ) ;
extern int xmlDOMWrapRemoveNode(xmlDOMWrapCtxtPtr ctxt , xmlDocPtr doc ,
                                xmlNodePtr node , int options ) ;
extern int xmlDOMWrapAdoptNode(xmlDOMWrapCtxtPtr ctxt , xmlDocPtr sourceDoc ,
                               xmlNodePtr node , xmlDocPtr destDoc ,
                               xmlNodePtr destParent , int options ) ;
extern int xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt ,
                                         xmlNodePtr elem , int options ) ;
extern void xmlDOMWrapFreeCtxt(xmlDOMWrapCtxtPtr ctxt ) ;
extern xmlDOMWrapCtxtPtr xmlDOMWrapNewCtxt(void) ;
extern void xmlSetCompressMode(int mode ) ;
extern int xmlGetCompressMode(void) ;
extern void xmlSetDocCompressMode(xmlDocPtr doc , int mode ) ;
extern int xmlGetDocCompressMode(xmlDocPtr doc ) ;
extern int xmlIsXHTML(xmlChar const   *systemID , xmlChar const   *publicID ) ;
extern int xmlSaveFileEnc(char const   *filename , xmlDocPtr cur ,
                          char const   *encoding ) ;
extern void xmlNodeDumpOutput(xmlOutputBufferPtr buf , xmlDocPtr doc ,
                              xmlNodePtr cur , int level , int format ,
                              char const   *encoding ) ;
extern int xmlSaveFormatFileTo(xmlOutputBufferPtr buf , xmlDocPtr cur ,
                               char const   *encoding , int format ) ;
extern int xmlSaveFileTo(xmlOutputBufferPtr buf , xmlDocPtr cur ,
                         char const   *encoding ) ;
extern int xmlSaveFormatFile(char const   *filename , xmlDocPtr cur ,
                             int format ) ;
extern int xmlSaveFile(char const   *filename , xmlDocPtr cur ) ;
extern void xmlElemDump(FILE *f , xmlDocPtr doc , xmlNodePtr cur ) ;
extern int xmlDocDump(FILE *f , xmlDocPtr cur ) ;
extern int xmlDocFormatDump(FILE *f , xmlDocPtr cur , int format ) ;
extern void xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc ,
                                      xmlChar **doc_txt_ptr , int *doc_txt_len ,
                                      char const   *txt_encoding , int format ) ;
extern void xmlDocDumpMemoryEnc(xmlDocPtr out_doc , xmlChar **doc_txt_ptr ,
                                int *doc_txt_len , char const   *txt_encoding ) ;
extern void xmlDocDumpMemory(xmlDocPtr cur , xmlChar **mem , int *size ) ;
extern int xmlReconciliateNs(xmlDocPtr doc , xmlNodePtr tree ) ;
extern void xmlAttrSerializeTxtContent(xmlBufferPtr buf , xmlDocPtr doc ,
                                       xmlAttrPtr attr ,
                                       xmlChar const   *string ) ;
extern void xmlBufferWriteQuotedString(xmlBufferPtr buf ,
                                       xmlChar const   *string ) ;
extern void xmlBufferWriteChar(xmlBufferPtr buf , char const   *string ) ;
extern void xmlBufferWriteCHAR(xmlBufferPtr buf , xmlChar const   *string ) ;
extern int xmlUnsetProp(xmlNodePtr node , xmlChar const   *name ) ;
extern int xmlUnsetNsProp(xmlNodePtr node , xmlNsPtr ns , xmlChar const   *name ) ;
extern int xmlRemoveProp(xmlAttrPtr cur ) ;
extern void xmlNodeSetBase(xmlNodePtr cur , xmlChar const   *uri ) ;
extern xmlChar *xmlNodeGetBase(xmlDocPtr doc , xmlNodePtr cur ) ;
extern void xmlNodeSetSpacePreserve(xmlNodePtr cur , int val ) ;
extern void xmlNodeSetLang(xmlNodePtr cur , xmlChar const   *lang ) ;
extern int xmlNodeGetSpacePreserve(xmlNodePtr cur ) ;
extern xmlChar *xmlNodeGetLang(xmlNodePtr cur ) ;
extern int xmlNodeBufGetContent(xmlBufferPtr buffer , xmlNodePtr cur ) ;
extern xmlChar *xmlNodeGetContent(xmlNodePtr cur ) ;
extern void xmlNodeAddContentLen(xmlNodePtr cur , xmlChar const   *content ,
                                 int len ) ;
extern void xmlNodeAddContent(xmlNodePtr cur , xmlChar const   *content ) ;
extern void xmlNodeSetContentLen(xmlNodePtr cur , xmlChar const   *content ,
                                 int len ) ;
extern void xmlNodeSetContent(xmlNodePtr cur , xmlChar const   *content ) ;
extern xmlChar *xmlNodeListGetRawString(xmlDocPtr doc , xmlNodePtr list ,
                                        int inLine ) ;
extern xmlChar *xmlNodeListGetString(xmlDocPtr doc , xmlNodePtr list ,
                                     int inLine ) ;
extern xmlNodePtr xmlStringLenGetNodeList(xmlDocPtr doc ,
                                          xmlChar const   *value , int len ) ;
extern xmlNodePtr xmlStringGetNodeList(xmlDocPtr doc , xmlChar const   *value ) ;
extern xmlChar *xmlGetNsProp(xmlNodePtr node , xmlChar const   *name ,
                             xmlChar const   *nameSpace ) ;
extern xmlAttrPtr xmlHasNsProp(xmlNodePtr node , xmlChar const   *name ,
                               xmlChar const   *nameSpace ) ;
extern xmlAttrPtr xmlHasProp(xmlNodePtr node , xmlChar const   *name ) ;
extern xmlChar *xmlGetProp(xmlNodePtr node , xmlChar const   *name ) ;
extern xmlChar *xmlGetNoNsProp(xmlNodePtr node , xmlChar const   *name ) ;
extern xmlAttrPtr xmlSetNsProp(xmlNodePtr node , xmlNsPtr ns ,
                               xmlChar const   *name , xmlChar const   *value ) ;
extern xmlAttrPtr xmlSetProp(xmlNodePtr node , xmlChar const   *name ,
                             xmlChar const   *value ) ;
extern xmlNsPtr xmlCopyNamespaceList(xmlNsPtr cur ) ;
extern xmlNsPtr xmlCopyNamespace(xmlNsPtr cur ) ;
extern xmlNsPtr *xmlGetNsList(xmlDocPtr doc , xmlNodePtr node ) ;
extern xmlNsPtr xmlSearchNs(xmlDocPtr doc , xmlNodePtr node ,
                            xmlChar const   *nameSpace ) ;
extern void xmlSetListDoc(xmlNodePtr list , xmlDocPtr doc ) ;
extern void xmlSetTreeDoc(xmlNodePtr tree , xmlDocPtr doc ) ;
extern void xmlFreeNodeList(xmlNodePtr cur ) ;
extern int xmlTextConcat(xmlNodePtr node , xmlChar const   *content , int len ) ;
extern xmlNodePtr xmlTextMerge(xmlNodePtr first , xmlNodePtr second ) ;
extern xmlNodePtr xmlAddNextSibling(xmlNodePtr cur , xmlNodePtr elem ) ;
extern xmlNodePtr xmlAddSibling(xmlNodePtr cur , xmlNodePtr elem ) ;
extern xmlNodePtr xmlAddPrevSibling(xmlNodePtr cur , xmlNodePtr elem ) ;
extern xmlNodePtr xmlReplaceNode(xmlNodePtr old , xmlNodePtr cur ) ;
extern xmlNodePtr xmlAddChildList(xmlNodePtr parent , xmlNodePtr cur ) ;
extern xmlNodePtr xmlAddChild(xmlNodePtr parent , xmlNodePtr cur ) ;
extern void xmlNodeSetName(xmlNodePtr cur , xmlChar const   *name ) ;
extern xmlNodePtr xmlDocSetRootElement(xmlDocPtr doc , xmlNodePtr root ) ;
extern int xmlIsBlankNode(xmlNodePtr node ) ;
extern int xmlNodeIsText(xmlNodePtr node ) ;
extern xmlNodePtr xmlGetLastChild(xmlNodePtr parent ) ;
extern xmlChar *xmlGetNodePath(xmlNodePtr node ) ;
extern long xmlGetLineNo(xmlNodePtr node ) ;
extern xmlNodePtr xmlNewDocRawNode(xmlDocPtr doc , xmlNsPtr ns ,
                                   xmlChar const   *name ,
                                   xmlChar const   *content ) ;
extern xmlNodePtr xmlNewTextChild(xmlNodePtr parent , xmlNsPtr ns ,
                                  xmlChar const   *name ,
                                  xmlChar const   *content ) ;
extern xmlNodePtr xmlCopyNodeList(xmlNodePtr node ) ;
extern xmlNodePtr xmlDocCopyNodeList(xmlDocPtr doc , xmlNodePtr node ) ;
extern xmlNodePtr xmlCopyNode(xmlNodePtr node , int recursive ) ;
extern xmlNodePtr xmlNewCharRef(xmlDocPtr doc , xmlChar const   *name ) ;
extern xmlNodePtr xmlNewComment(xmlChar const   *content ) ;
extern xmlNodePtr xmlNewTextLen(xmlChar const   *content , int len ) ;
extern xmlNodePtr xmlNewDocTextLen(xmlDocPtr doc , xmlChar const   *content ,
                                   int len ) ;
extern xmlNodePtr xmlNewDocPI(xmlDocPtr doc , xmlChar const   *name ,
                              xmlChar const   *content ) ;
extern xmlNodePtr xmlNewText(xmlChar const   *content ) ;
extern xmlNodePtr xmlNewChild(xmlNodePtr parent , xmlNsPtr ns ,
                              xmlChar const   *name , xmlChar const   *content ) ;
extern xmlNodePtr xmlNewNodeEatName(xmlNsPtr ns , xmlChar *name ) ;
extern xmlNodePtr xmlNewNode(xmlNsPtr ns , xmlChar const   *name ) ;
extern xmlNodePtr xmlNewDocNodeEatName(xmlDocPtr doc , xmlNsPtr ns ,
                                       xmlChar *name , xmlChar const   *content ) ;
extern xmlDocPtr xmlCopyDoc(xmlDocPtr doc , int recursive ) ;
extern xmlDtdPtr xmlCopyDtd(xmlDtdPtr dtd ) ;
extern xmlAttrPtr xmlCopyPropList(xmlNodePtr target , xmlAttrPtr cur ) ;
extern xmlAttrPtr xmlCopyProp(xmlNodePtr target , xmlAttrPtr cur ) ;
extern void xmlFreePropList(xmlAttrPtr cur ) ;
extern xmlAttrPtr xmlNewNsPropEatName(xmlNodePtr node , xmlNsPtr ns ,
                                      xmlChar *name , xmlChar const   *value ) ;
extern xmlAttrPtr xmlNewNsProp(xmlNodePtr node , xmlNsPtr ns ,
                               xmlChar const   *name , xmlChar const   *value ) ;
extern xmlAttrPtr xmlNewProp(xmlNodePtr node , xmlChar const   *name ,
                             xmlChar const   *value ) ;
extern void xmlFreeNsList(xmlNsPtr cur ) ;
extern void xmlFreeNs(xmlNsPtr cur ) ;
extern xmlNsPtr xmlNewNs(xmlNodePtr node , xmlChar const   *href ,
                         xmlChar const   *prefix ) ;
extern xmlNsPtr xmlNewGlobalNs(xmlDocPtr doc , xmlChar const   *href ,
                               xmlChar const   *prefix ) ;
extern void xmlFreeDtd(xmlDtdPtr cur ) ;
extern xmlDtdPtr xmlNewDtd(xmlDocPtr doc , xmlChar const   *name ,
                           xmlChar const   *ExternalID ,
                           xmlChar const   *SystemID ) ;
extern xmlDtdPtr xmlCreateIntSubset(xmlDocPtr doc , xmlChar const   *name ,
                                    xmlChar const   *ExternalID ,
                                    xmlChar const   *SystemID ) ;
extern int xmlBufferLength(xmlBufferPtr buf ) ;
extern void xmlBufferSetAllocationScheme(xmlBufferPtr buf ,
                                         xmlBufferAllocationScheme scheme ) ;
extern void xmlBufferEmpty(xmlBufferPtr buf ) ;
extern int xmlBufferGrow(xmlBufferPtr buf , unsigned int len ) ;
extern int xmlBufferShrink(xmlBufferPtr buf , unsigned int len ) ;
extern int xmlBufferCCat(xmlBufferPtr buf , char const   *str ) ;
extern int xmlBufferCat(xmlBufferPtr buf , xmlChar const   *str ) ;
extern int xmlBufferAddHead(xmlBufferPtr buf , xmlChar const   *str , int len ) ;
extern int xmlBufferAdd(xmlBufferPtr buf , xmlChar const   *str , int len ) ;
extern int xmlBufferDump(FILE *file , xmlBufferPtr buf ) ;
extern int xmlBufferResize(xmlBufferPtr buf , unsigned int size ) ;
extern xmlBufferPtr xmlBufferCreateStatic(void *mem , size_t size ) ;
extern xmlBufferPtr xmlBufferCreateSize(size_t size ) ;
extern xmlBufferAllocationScheme xmlGetBufferAllocationScheme(void) ;
extern void xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme ) ;
extern xmlChar const   *xmlSplitQName3(xmlChar const   *name , int *len ) ;
extern xmlChar *xmlSplitQName2(xmlChar const   *name , xmlChar **prefix ) ;
extern xmlChar *xmlBuildQName(xmlChar const   *ncname ,
                              xmlChar const   *prefix , xmlChar *memory ,
                              int len ) ;
extern int xmlValidateNMToken(xmlChar const   *value , int space ) ;
extern int xmlValidateQName(xmlChar const   *value , int space ) ;
extern int xmlValidateNCName(xmlChar const   *value , int space ) ;
struct _xmlExpNode;
typedef struct _xmlExpNode xmlExpNode;
typedef xmlExpNode *xmlExpNodePtr;
extern void xmlExpDump(xmlBufferPtr buf , xmlExpNodePtr expr ) ;
struct _xmlExpCtxt;
typedef struct _xmlExpCtxt xmlExpCtxt;
typedef xmlExpCtxt *xmlExpCtxtPtr;
extern int xmlExpSubsume(xmlExpCtxtPtr ctxt , xmlExpNodePtr expr ,
                         xmlExpNodePtr sub ) ;
extern xmlExpNodePtr xmlExpExpDerive(xmlExpCtxtPtr ctxt , xmlExpNodePtr expr ,
                                     xmlExpNodePtr sub ) ;
extern xmlExpNodePtr xmlExpStringDerive(xmlExpCtxtPtr ctxt ,
                                        xmlExpNodePtr expr ,
                                        xmlChar const   *str , int len ) ;
extern int xmlExpGetStart(xmlExpCtxtPtr ctxt , xmlExpNodePtr expr ,
                          xmlChar const   **tokList , int len ) ;
extern int xmlExpGetLanguage(xmlExpCtxtPtr ctxt , xmlExpNodePtr expr ,
                             xmlChar const   **langList , int len ) ;
extern int xmlExpMaxToken(xmlExpNodePtr expr ) ;
extern int xmlExpIsNillable(xmlExpNodePtr expr ) ;
extern xmlExpNodePtr xmlExpNewRange(xmlExpCtxtPtr ctxt , xmlExpNodePtr subset ,
                                    int min , int max ) ;
extern xmlExpNodePtr xmlExpNewSeq(xmlExpCtxtPtr ctxt , xmlExpNodePtr left ,
                                  xmlExpNodePtr right ) ;
extern xmlExpNodePtr xmlExpNewOr(xmlExpCtxtPtr ctxt , xmlExpNodePtr left ,
                                 xmlExpNodePtr right ) ;
extern xmlExpNodePtr xmlExpNewAtom(xmlExpCtxtPtr ctxt , xmlChar const   *name ,
                                   int len ) ;
extern xmlExpNodePtr xmlExpParse(xmlExpCtxtPtr ctxt , char const   *expr ) ;
extern void xmlExpRef(xmlExpNodePtr expr ) ;
extern void xmlExpFree(xmlExpCtxtPtr ctxt , xmlExpNodePtr expr ) ;
extern xmlExpNodePtr emptyExp ;
extern xmlExpNodePtr forbiddenExp ;
extern int xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt ) ;
extern int xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt ) ;
extern xmlExpCtxtPtr xmlExpNewCtxt(int maxNodes , xmlDictPtr dict ) ;
extern void xmlExpFreeCtxt(xmlExpCtxtPtr ctxt ) ;
struct _xmlRegExecCtxt;
typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;
extern int xmlRegExecErrInfo(xmlRegExecCtxtPtr exec , xmlChar const   **string ,
                             int *nbval , int *nbneg , xmlChar **values ,
                             int *terminal ) ;
extern int xmlRegExecNextValues(xmlRegExecCtxtPtr exec , int *nbval ,
                                int *nbneg , xmlChar **values , int *terminal ) ;
extern int xmlRegExecPushString2(xmlRegExecCtxtPtr exec ,
                                 xmlChar const   *value ,
                                 xmlChar const   *value2 , void *data ) ;
extern int xmlRegExecPushString(xmlRegExecCtxtPtr exec ,
                                xmlChar const   *value , void *data ) ;
extern void xmlRegFreeExecCtxt(xmlRegExecCtxtPtr exec ) ;
extern xmlRegExecCtxtPtr xmlRegNewExecCtxt(xmlRegexpPtr comp ,
                                           void (*callback)(xmlRegExecCtxtPtr exec ,
                                                            xmlChar const   *token ,
                                                            void *transdata ,
                                                            void *inputdata ) ,
                                           void *data ) ;
extern int xmlRegexpIsDeterminist(xmlRegexpPtr comp ) ;
extern void xmlRegexpPrint(FILE *output , xmlRegexpPtr regexp ) ;
extern int xmlRegexpExec(xmlRegexpPtr comp , xmlChar const   *value ) ;
extern void xmlRegFreeRegexp(xmlRegexpPtr regexp ) ;
extern xmlRegexpPtr xmlRegexpCompile(xmlChar const   *regexp ) ;
extern void xmlDictCleanup(void) ;
extern int xmlDictSize(xmlDictPtr dict ) ;
extern int xmlDictOwns(xmlDictPtr dict , xmlChar const   *str ) ;
extern xmlChar const   *xmlDictQLookup(xmlDictPtr dict ,
                                       xmlChar const   *prefix ,
                                       xmlChar const   *name ) ;
extern xmlChar const   *xmlDictExists(xmlDictPtr dict , xmlChar const   *name ,
                                      int len ) ;
extern xmlChar const   *xmlDictLookup(xmlDictPtr dict , xmlChar const   *name ,
                                      int len ) ;
extern void xmlDictFree(xmlDictPtr dict ) ;
extern int xmlDictReference(xmlDictPtr dict ) ;
extern xmlDictPtr xmlDictCreateSub(xmlDictPtr sub ) ;
extern xmlDictPtr xmlDictCreate(void) ;
extern int xmlUTF8Charcmp(xmlChar const   *utf1 , xmlChar const   *utf2 ) ;
extern int xmlUTF8Size(xmlChar const   *utf ) ;
extern int xmlUTF8Strlen(xmlChar const   *utf ) ;
extern xmlChar *xmlUTF8Strsub(xmlChar const   *utf , int start , int len ) ;
extern int xmlUTF8Strloc(xmlChar const   *utf , xmlChar const   *utfchar ) ;
extern xmlChar const   *xmlUTF8Strpos(xmlChar const   *utf , int pos ) ;
extern xmlChar *xmlUTF8Strndup(xmlChar const   *utf , int len ) ;
extern int xmlUTF8Strsize(xmlChar const   *utf , int len ) ;
extern int xmlCheckUTF8(unsigned char const   *utf ) ;
extern int xmlGetUTF8Char(unsigned char const   *utf , int *len ) ;
typedef __builtin_va_list __gnuc_va_list;
typedef __gnuc_va_list va_list;
extern int xmlStrVPrintf(xmlChar *buf , int len , xmlChar const   *msg ,
                         va_list ap ) ;
extern int xmlStrPrintf(xmlChar *buf , int len , xmlChar const   *msg  , ...) ;
extern xmlChar *xmlStrncatNew(xmlChar const   *str1 , xmlChar const   *str2 ,
                              int len ) ;
extern xmlChar *xmlStrncat(xmlChar *cur , xmlChar const   *add , int len ) ;
extern xmlChar *xmlStrcat(xmlChar *cur , xmlChar const   *add ) ;
extern int xmlStrQEqual(xmlChar const   *pref , xmlChar const   *name ,
                        xmlChar const   *str ) ;
extern int xmlStrEqual(xmlChar const   *str1 , xmlChar const   *str2 ) ;
extern int xmlStrncasecmp(xmlChar const   *str1 , xmlChar const   *str2 ,
                          int len ) ;
extern int xmlStrcasecmp(xmlChar const   *str1 , xmlChar const   *str2 ) ;
extern int xmlStrncmp(xmlChar const   *str1 , xmlChar const   *str2 , int len ) ;
extern int xmlStrcmp(xmlChar const   *str1 , xmlChar const   *str2 ) ;
extern xmlChar const   *xmlStrcasestr(xmlChar const   *str ,
                                      xmlChar const   *val ) ;
extern xmlChar const   *xmlStrstr(xmlChar const   *str , xmlChar const   *val ) ;
extern xmlChar const   *xmlStrchr(xmlChar const   *str , xmlChar val ) ;
extern xmlChar *xmlStrsub(xmlChar const   *str , int start , int len ) ;
extern xmlChar *xmlCharStrdup(char const   *cur ) ;
extern xmlChar *xmlStrndup(xmlChar const   *cur , int len ) ;
extern void xmlCheckVersion(int version ) ;
extern zend_module_entry dom_module_entry ;
struct tm;
extern int getdate_r(char const   * __restrict  __string ,
                     struct tm * __restrict  __resbufp ) ;
extern struct tm *getdate(char const   *__string ) ;
extern int getdate_err ;
typedef void *__timer_t;
typedef __timer_t timer_t;
extern  __attribute__((__nothrow__)) int timer_getoverrun(timer_t __timerid ) ;
struct itimerspec;
extern  __attribute__((__nothrow__)) int timer_gettime(timer_t __timerid ,
                                                       struct itimerspec *__value ) ;
extern  __attribute__((__nothrow__)) int timer_settime(timer_t __timerid ,
                                                       int __flags ,
                                                       struct itimerspec  const  * __restrict  __value ,
                                                       struct itimerspec * __restrict  __ovalue ) ;
extern  __attribute__((__nothrow__)) int timer_delete(timer_t __timerid ) ;
struct sigevent;
typedef int __clockid_t;
typedef __clockid_t clockid_t;
extern  __attribute__((__nothrow__)) int timer_create(clockid_t __clock_id ,
                                                      struct sigevent * __restrict  __evp ,
                                                      timer_t * __restrict  __timerid ) ;
typedef int __pid_t;
typedef __pid_t pid_t;
extern  __attribute__((__nothrow__)) int clock_getcpuclockid(pid_t __pid ,
                                                             clockid_t *__clock_id ) ;
struct timespec;
extern int clock_nanosleep(clockid_t __clock_id , int __flags ,
                           struct timespec  const  *__req ,
                           struct timespec *__rem ) ;
extern  __attribute__((__nothrow__)) int clock_settime(clockid_t __clock_id ,
                                                       struct timespec  const  *__tp ) ;
extern  __attribute__((__nothrow__)) int clock_gettime(clockid_t __clock_id ,
                                                       struct timespec *__tp ) ;
extern  __attribute__((__nothrow__)) int clock_getres(clockid_t __clock_id ,
                                                      struct timespec *__res ) ;
extern int nanosleep(struct timespec  const  *__requested_time ,
                     struct timespec *__remaining ) ;
extern  __attribute__((__nothrow__)) int dysize(int __year )  __attribute__((__const__)) ;
typedef long __time_t;
typedef __time_t time_t;
extern  __attribute__((__nothrow__)) time_t timelocal(struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) time_t timegm(struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) int stime(time_t const   *__when ) ;
extern long timezone ;
extern int daylight ;
extern  __attribute__((__nothrow__)) void tzset(void) ;
extern char *tzname[2] ;
extern long __timezone ;
extern int __daylight ;
extern char *__tzname[2] ;
extern  __attribute__((__nothrow__)) char *ctime_r(time_t const   * __restrict  __timer ,
                                                   char * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) char *asctime_r(struct tm  const  * __restrict  __tp ,
                                                     char * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) char *ctime(time_t const   *__timer ) ;
extern  __attribute__((__nothrow__)) char *asctime(struct tm  const  *__tp ) ;
extern  __attribute__((__nothrow__)) struct tm *localtime_r(time_t const   * __restrict  __timer ,
                                                            struct tm * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) struct tm *gmtime_r(time_t const   * __restrict  __timer ,
                                                         struct tm * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) struct tm *localtime(time_t const   *__timer ) ;
extern  __attribute__((__nothrow__)) struct tm *gmtime(time_t const   *__timer ) ;
struct __locale_struct;
typedef struct __locale_struct *__locale_t;
extern  __attribute__((__nothrow__)) char *strptime_l(char const   * __restrict  __s ,
                                                      char const   * __restrict  __fmt ,
                                                      struct tm *__tp ,
                                                      __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) size_t strftime_l(char * __restrict  __s ,
                                                       size_t __maxsize ,
                                                       char const   * __restrict  __format ,
                                                       struct tm  const  * __restrict  __tp ,
                                                       __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) char *strptime(char const   * __restrict  __s ,
                                                    char const   * __restrict  __fmt ,
                                                    struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) size_t strftime(char * __restrict  __s ,
                                                     size_t __maxsize ,
                                                     char const   * __restrict  __format ,
                                                     struct tm  const  * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) time_t mktime(struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) double difftime(time_t __time1 ,
                                                     time_t __time0 )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) time_t time(time_t *__timer ) ;
typedef long __clock_t;
typedef __clock_t clock_t;
extern  __attribute__((__nothrow__)) clock_t clock(void) ;
struct _zend_constant;
typedef struct _zend_constant zend_constant;
extern zend_constant *zend_quick_get_constant(zend_literal const   *key ,
                                              ulong flags ) ;
extern void copy_zend_constant(zend_constant *c ) ;
extern void zend_copy_constants(HashTable *target , HashTable *sourc ) ;
extern int __attribute__((__visibility__("default")))  zend_register_constant(zend_constant *c ) ;
extern void __attribute__((__visibility__("default")))  zend_register_stringl_constant(char const   *name ,
                                                                                       uint name_len ,
                                                                                       char *strval ,
                                                                                       uint strlen ,
                                                                                       int flags ,
                                                                                       int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_register_string_constant(char const   *name ,
                                                                                      uint name_len ,
                                                                                      char *strval ,
                                                                                      int flags ,
                                                                                      int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_register_double_constant(char const   *name ,
                                                                                      uint name_len ,
                                                                                      double dval ,
                                                                                      int flags ,
                                                                                      int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_register_long_constant(char const   *name ,
                                                                                    uint name_len ,
                                                                                    long lval ,
                                                                                    int flags ,
                                                                                    int module_number ) ;
extern int __attribute__((__visibility__("default")))  zend_get_constant_ex(char const   *name ,
                                                                            uint name_len ,
                                                                            zval *result ,
                                                                            zend_class_entry *scope ,
                                                                            ulong flags ) ;
extern int __attribute__((__visibility__("default")))  zend_get_constant(char const   *name ,
                                                                         uint name_len ,
                                                                         zval *result ) ;
extern void clean_non_persistent_constants(void) ;
extern void zend_register_standard_constants(void) ;
extern int zend_shutdown_constants(void) ;
extern int zend_startup_constants(void) ;
extern void free_zend_constant(zend_constant *c ) ;
extern void clean_module_constants(int module_number ) ;
struct _realpath_cache_bucket;
typedef struct _realpath_cache_bucket realpath_cache_bucket;
extern realpath_cache_bucket __attribute__((__visibility__("default")))  **realpath_cache_get_buckets(void) ;
extern int __attribute__((__visibility__("default")))  realpath_cache_max_buckets(void) ;
extern int __attribute__((__visibility__("default")))  realpath_cache_size(void) ;
extern realpath_cache_bucket __attribute__((__visibility__("default")))  *realpath_cache_lookup(char const   *path ,
                                                                                                int path_len ,
                                                                                                time_t t ) ;
extern void __attribute__((__visibility__("default")))  realpath_cache_del(char const   *path ,
                                                                           int path_len ) ;
extern void __attribute__((__visibility__("default")))  realpath_cache_clean(void) ;
struct _virtual_cwd_globals;
typedef struct _virtual_cwd_globals virtual_cwd_globals;
extern virtual_cwd_globals cwd_globals ;
struct _cwd_state;
typedef struct _cwd_state cwd_state;
extern int __attribute__((__visibility__("default")))  virtual_file_ex(cwd_state *state ,
                                                                       char const   *path ,
                                                                       int (*verify_path)(cwd_state const   * ) ,
                                                                       int use_realpath ) ;
typedef unsigned int __gid_t;
typedef __gid_t gid_t;
typedef unsigned int __uid_t;
typedef __uid_t uid_t;
extern int __attribute__((__visibility__("default")))  virtual_chown(char const   *filename ,
                                                                     uid_t owner ,
                                                                     gid_t group ,
                                                                     int link ) ;
typedef unsigned int __mode_t;
typedef __mode_t mode_t;
extern int __attribute__((__visibility__("default")))  virtual_chmod(char const   *filename ,
                                                                     mode_t mode ) ;
struct utimbuf;
extern int __attribute__((__visibility__("default")))  virtual_utime(char const   *filename ,
                                                                     struct utimbuf *buf ) ;
extern int __attribute__((__visibility__("default")))  virtual_access(char const   *pathname ,
                                                                      int mode ) ;
extern FILE __attribute__((__visibility__("default")))  *virtual_popen(char const   *command ,
                                                                       char const   *type ) ;
struct __dirstream;
typedef struct __dirstream DIR;
extern DIR __attribute__((__visibility__("default")))  *virtual_opendir(char const   *pathname ) ;
extern int __attribute__((__visibility__("default")))  virtual_rmdir(char const   *pathname ) ;
extern int __attribute__((__visibility__("default")))  virtual_mkdir(char const   *pathname ,
                                                                     mode_t mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_unlink(char const   *path ) ;
struct stat;
extern int __attribute__((__visibility__("default")))  virtual_lstat(char const   *path ,
                                                                     struct stat *buf ) ;
extern int __attribute__((__visibility__("default")))  virtual_stat(char const   *path ,
                                                                    struct stat *buf ) ;
extern int __attribute__((__visibility__("default")))  virtual_rename(char *oldname ,
                                                                      char *newname ) ;
extern int __attribute__((__visibility__("default")))  virtual_creat(char const   *path ,
                                                                     mode_t mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_open(char const   *path ,
                                                                    int flags 
                                                                    , ...) ;
extern FILE __attribute__((__visibility__("default")))  *virtual_fopen(char const   *path ,
                                                                       char const   *mode ) ;
extern char __attribute__((__visibility__("default")))  *virtual_realpath(char const   *path ,
                                                                          char *real_path ) ;
extern int __attribute__((__visibility__("default")))  virtual_filepath_ex(char const   *path ,
                                                                           char **filepath ,
                                                                           int (*verify_path)(cwd_state const   * ) ) ;
extern int __attribute__((__visibility__("default")))  virtual_filepath(char const   *path ,
                                                                        char **filepath ) ;
extern int __attribute__((__visibility__("default")))  virtual_chdir_file(char const   *path ,
                                                                          int (*p_chdir)(char const   *path ) ) ;
extern int __attribute__((__visibility__("default")))  virtual_chdir(char const   *path ) ;
extern char __attribute__((__visibility__("default")))  *virtual_getcwd(char *buf ,
                                                                        size_t size ) ;
extern char __attribute__((__visibility__("default")))  *virtual_getcwd_ex(size_t *length ) ;
extern void __attribute__((__visibility__("default")))  virtual_cwd_shutdown(void) ;
extern void __attribute__((__visibility__("default")))  virtual_cwd_startup(void) ;
struct dirent64;
extern  __attribute__((__nothrow__)) int versionsort64(struct dirent64  const  **__e1 ,
                                                       struct dirent64  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
struct dirent;
extern  __attribute__((__nothrow__)) int versionsort(struct dirent  const  **__e1 ,
                                                     struct dirent  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
typedef long long __quad_t;
typedef __quad_t __off64_t;
typedef int __ssize_t;
extern  __attribute__((__nothrow__)) __ssize_t getdirentries64(int __fd ,
                                                               char * __restrict  __buf ,
                                                               size_t __nbytes ,
                                                               __off64_t * __restrict  __basep )  __attribute__((__nonnull__(2,4))) ;
typedef long __off_t;
extern  __attribute__((__nothrow__)) __ssize_t getdirentries(int __fd ,
                                                             char * __restrict  __buf ,
                                                             size_t __nbytes ,
                                                             __off_t * __restrict  __basep )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) int alphasort64(struct dirent64  const  **__e1 ,
                                                     struct dirent64  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int alphasort(struct dirent  const  **__e1 ,
                                                   struct dirent  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern int scandir64(char const   * __restrict  __dir ,
                     struct dirent64 *** __restrict  __namelist ,
                     int (*__selector)(struct dirent64  const  * ) ,
                     int (*__cmp)(struct dirent64  const  ** ,
                                  struct dirent64  const  ** ) )  __attribute__((__nonnull__(1,2))) ;
extern int scandir(char const   * __restrict  __dir ,
                   struct dirent *** __restrict  __namelist ,
                   int (*__selector)(struct dirent  const  * ) ,
                   int (*__cmp)(struct dirent  const  ** ,
                                struct dirent  const  ** ) )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int dirfd(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long telldir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void seekdir(DIR *__dirp , long __pos )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void rewinddir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern int readdir64_r(DIR * __restrict  __dirp ,
                       struct dirent64 * __restrict  __entry ,
                       struct dirent64 ** __restrict  __result )  __attribute__((__nonnull__(1,2,3))) ;
extern int readdir_r(DIR * __restrict  __dirp ,
                     struct dirent * __restrict  __entry ,
                     struct dirent ** __restrict  __result )  __attribute__((__nonnull__(1,2,3))) ;
extern struct dirent64 *readdir64(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern struct dirent *readdir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern int closedir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern DIR *fdopendir(int __fd ) ;
extern DIR *opendir(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int utime(char const   *__file ,
                                               struct utimbuf  const  *__file_times )  __attribute__((__nonnull__(1))) ;
extern int __attribute__((__visibility__("default")))  OnUpdateBaseDir(zend_ini_entry *entry ,
                                                                       char *new_value ,
                                                                       uint new_value_length ,
                                                                       void *mh_arg1 ,
                                                                       void *mh_arg2 ,
                                                                       void *mh_arg3 ,
                                                                       int stage ) ;
extern char __attribute__((__visibility__("default")))  *php_strip_url_passwd(char *path ) ;
extern FILE __attribute__((__visibility__("default")))  *php_fopen_with_path(char const   *filename ,
                                                                             char const   *mode ,
                                                                             char const   *path ,
                                                                             char **opened_path ) ;
extern char __attribute__((__visibility__("default")))  *php_resolve_path(char const   *filename ,
                                                                          int filename_len ,
                                                                          char const   *path ) ;
extern int __attribute__((__visibility__("default")))  php_check_safe_mode_include_dir(char const   *path ) ;
extern int __attribute__((__visibility__("default")))  php_check_specific_open_basedir(char const   *basedir ,
                                                                                       char const   *path ) ;
extern int __attribute__((__visibility__("default")))  php_check_open_basedir_ex(char const   *path ,
                                                                                 int warn ) ;
extern int __attribute__((__visibility__("default")))  php_check_open_basedir(char const   *path ) ;
extern char __attribute__((__visibility__("default")))  *expand_filepath_ex(char const   *filepath ,
                                                                            char *real_path ,
                                                                            char const   *relative_to ,
                                                                            size_t relative_to_len ) ;
struct _zend_file_handle;
typedef struct _zend_file_handle zend_file_handle;
extern int __attribute__((__visibility__("default")))  php_fopen_primary_script(zend_file_handle *file_handle ) ;
extern HashTable __attribute__((__visibility__("default")))  *php_ini_get_configuration_hash(void) ;
extern void __attribute__((__visibility__("default")))  php_ini_activate_per_host_config(char const   *host ,
                                                                                         uint host_len ) ;
extern void __attribute__((__visibility__("default")))  php_ini_activate_per_dir_config(char *path ,
                                                                                        uint path_len ) ;
extern int __attribute__((__visibility__("default")))  php_ini_has_per_host_config(void) ;
extern int __attribute__((__visibility__("default")))  php_ini_has_per_dir_config(void) ;
extern void __attribute__((__visibility__("default")))  php_ini_activate_config(HashTable *source_hash ,
                                                                                int modify_type ,
                                                                                int stage ) ;
extern int __attribute__((__visibility__("default")))  php_parse_user_ini_file(char const   *dirname ,
                                                                               char *ini_filename ,
                                                                               HashTable *target_hash ) ;
extern int __attribute__((__visibility__("default")))  cfg_get_string(char const   *varname ,
                                                                      char **result ) ;
extern int __attribute__((__visibility__("default")))  cfg_get_double(char const   *varname ,
                                                                      double *result ) ;
extern int __attribute__((__visibility__("default")))  cfg_get_long(char const   *varname ,
                                                                    long *result ) ;
extern zval __attribute__((__visibility__("default")))  *cfg_get_entry(char const   *name ,
                                                                       uint name_length ) ;
extern void php_ini_register_extensions(void) ;
extern int php_shutdown_config(void) ;
extern int php_init_config(void) ;
extern void __attribute__((__visibility__("default")))  config_zval_dtor(zval *zvalue ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_ini_string(char *str ,
                                                                             zend_bool unbuffered_errors ,
                                                                             int scanner_mode ,
                                                                             void (*ini_parser_cb)(zval *arg1 ,
                                                                                                   zval *arg2 ,
                                                                                                   zval *arg3 ,
                                                                                                   int callback_type ,
                                                                                                   void *arg ) ,
                                                                             void *arg ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_ini_file(zend_file_handle *fh ,
                                                                           zend_bool unbuffered_errors ,
                                                                           int scanner_mode ,
                                                                           void (*ini_parser_cb)(zval *arg1 ,
                                                                                                 zval *arg2 ,
                                                                                                 zval *arg3 ,
                                                                                                 int callback_type ,
                                                                                                 void *arg ) ,
                                                                           void *arg ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateStringUnempty(zend_ini_entry *entry ,
                                                                             char *new_value ,
                                                                             uint new_value_length ,
                                                                             void *mh_arg1 ,
                                                                             void *mh_arg2 ,
                                                                             void *mh_arg3 ,
                                                                             int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateString(zend_ini_entry *entry ,
                                                                      char *new_value ,
                                                                      uint new_value_length ,
                                                                      void *mh_arg1 ,
                                                                      void *mh_arg2 ,
                                                                      void *mh_arg3 ,
                                                                      int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateReal(zend_ini_entry *entry ,
                                                                    char *new_value ,
                                                                    uint new_value_length ,
                                                                    void *mh_arg1 ,
                                                                    void *mh_arg2 ,
                                                                    void *mh_arg3 ,
                                                                    int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateLongGEZero(zend_ini_entry *entry ,
                                                                          char *new_value ,
                                                                          uint new_value_length ,
                                                                          void *mh_arg1 ,
                                                                          void *mh_arg2 ,
                                                                          void *mh_arg3 ,
                                                                          int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateLong(zend_ini_entry *entry ,
                                                                    char *new_value ,
                                                                    uint new_value_length ,
                                                                    void *mh_arg1 ,
                                                                    void *mh_arg2 ,
                                                                    void *mh_arg3 ,
                                                                    int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateBool(zend_ini_entry *entry ,
                                                                    char *new_value ,
                                                                    uint new_value_length ,
                                                                    void *mh_arg1 ,
                                                                    void *mh_arg2 ,
                                                                    void *mh_arg3 ,
                                                                    int stage ) ;
extern void __attribute__((__visibility__("default")))  display_link_numbers(zend_ini_entry *ini_entry ,
                                                                             int type ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_color_displayer_cb(zend_ini_entry *ini_entry ,
                                                                                    int type ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_boolean_displayer_cb(zend_ini_entry *ini_entry ,
                                                                                      int type ) ;
extern int __attribute__((__visibility__("default")))  zend_ini_register_displayer(char *name ,
                                                                                   uint name_length ,
                                                                                   void (*displayer)(zend_ini_entry *ini_entry ,
                                                                                                     int type ) ) ;
extern char __attribute__((__visibility__("default")))  *zend_ini_string_ex(char *name ,
                                                                            uint name_length ,
                                                                            int orig ,
                                                                            zend_bool *exists ) ;
extern char __attribute__((__visibility__("default")))  *zend_ini_string(char *name ,
                                                                         uint name_length ,
                                                                         int orig ) ;
extern double __attribute__((__visibility__("default")))  zend_ini_double(char *name ,
                                                                          uint name_length ,
                                                                          int orig ) ;
extern long __attribute__((__visibility__("default")))  zend_ini_long(char *name ,
                                                                      uint name_length ,
                                                                      int orig ) ;
extern void __attribute__((__visibility__("default")))  display_ini_entries(zend_module_entry *module ) ;
extern int __attribute__((__visibility__("default")))  zend_restore_ini_entry(char *name ,
                                                                              uint name_length ,
                                                                              int stage ) ;
extern int __attribute__((__visibility__("default")))  zend_alter_ini_entry_ex(char *name ,
                                                                               uint name_length ,
                                                                               char *new_value ,
                                                                               uint new_value_length ,
                                                                               int modify_type ,
                                                                               int stage ,
                                                                               int force_change ) ;
extern int __attribute__((__visibility__("default")))  zend_alter_ini_entry(char *name ,
                                                                            uint name_length ,
                                                                            char *new_value ,
                                                                            uint new_value_length ,
                                                                            int modify_type ,
                                                                            int stage ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_refresh_caches(int stage ) ;
extern void __attribute__((__visibility__("default")))  zend_unregister_ini_entries(int module_number ) ;
extern int __attribute__((__visibility__("default")))  zend_register_ini_entries(zend_ini_entry const   *ini_entry ,
                                                                                 int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_sort_entries(void) ;
extern int __attribute__((__visibility__("default")))  zend_copy_ini_directives(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_deactivate(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_global_shutdown(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_shutdown(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_startup(void) ;
struct _php_core_globals;
extern struct _php_core_globals  __attribute__((__visibility__("default"))) core_globals ;
struct _php_stream_wrapper;
typedef struct _php_stream_wrapper php_stream_wrapper;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_stream_rfc2397_wrapper ;
struct _php_stream_ops;
typedef struct _php_stream_ops php_stream_ops;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_rfc2397_ops ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_temp_ops ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_memory_ops ;
struct _php_stream;
typedef struct _php_stream php_stream;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_temp_open(int mode ,
                                                                                     size_t max_memory_usage ,
                                                                                     char *buf ,
                                                                                     size_t length ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_temp_create(int mode ,
                                                                                       size_t max_memory_usage ) ;
extern char __attribute__((__visibility__("default")))  *_php_stream_memory_get_buffer(php_stream *stream ,
                                                                                       size_t *length ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_memory_open(int mode ,
                                                                                       char *buf ,
                                                                                       size_t length ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_memory_create(int mode ) ;
struct _php_stream_wrapper_ops;
typedef struct _php_stream_wrapper_ops php_stream_wrapper_ops;
extern php_stream_wrapper_ops *php_stream_user_wrapper_ops ;
extern HashTable __attribute__((__visibility__("default")))  *php_get_stream_filters_hash_global(void) ;
extern HashTable __attribute__((__visibility__("default")))  *_php_get_stream_filters_hash(void) ;
extern HashTable __attribute__((__visibility__("default")))  *php_stream_get_url_stream_wrappers_hash_global(void) ;
extern HashTable __attribute__((__visibility__("default")))  *_php_stream_get_url_stream_wrappers_hash(void) ;
extern int __attribute__((__visibility__("default")))  _php_stream_make_seekable(php_stream *origstream ,
                                                                                 php_stream **newstream ,
                                                                                 int flags ) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  php_stream_wrapper_log_error)(php_stream_wrapper *wrapper ,
                                                                                                                int options ,
                                                                                                                char const   *fmt 
                                                                                                                , ...) ;
extern char __attribute__((__visibility__("default")))  *php_stream_locate_eol(php_stream *stream ,
                                                                               char *buf ,
                                                                               size_t buf_len ) ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  *php_stream_locate_url_wrapper(char const   *path ,
                                                                                                     char **path_for_open ,
                                                                                                     int options ) ;
struct _php_stream_context;
typedef struct _php_stream_context php_stream_context;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_open_wrapper_ex(char *path ,
                                                                                           char *mode ,
                                                                                           int options ,
                                                                                           char **opened_path ,
                                                                                           php_stream_context *context ) ;
extern int __attribute__((__visibility__("default")))  php_unregister_url_stream_wrapper_volatile(char *protocol ) ;
extern int __attribute__((__visibility__("default")))  php_register_url_stream_wrapper_volatile(char *protocol ,
                                                                                                php_stream_wrapper *wrapper ) ;
extern int __attribute__((__visibility__("default")))  php_unregister_url_stream_wrapper(char *protocol ) ;
extern int __attribute__((__visibility__("default")))  php_register_url_stream_wrapper(char *protocol ,
                                                                                       php_stream_wrapper *wrapper ) ;
extern int zm_deactivate_streams(int type , int module_number ) ;
extern void php_shutdown_stream_hashes(void) ;
extern int php_shutdown_stream_wrappers(int module_number ) ;
extern int php_init_stream_wrappers(int module_number ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_cast(php_stream *stream ,
                                                                        int castas ,
                                                                        void **ret ,
                                                                        int show_err ) ;
typedef __off_t off_t;
extern int __attribute__((__visibility__("default")))  _php_stream_mmap_unmap_ex(php_stream *stream ,
                                                                                 off_t readden ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_mmap_unmap(php_stream *stream ) ;
enum __anonenum_php_stream_mmap_operation_t_76;
typedef enum __anonenum_php_stream_mmap_operation_t_76 php_stream_mmap_operation_t;
extern char __attribute__((__visibility__("default")))  *_php_stream_mmap_range(php_stream *stream ,
                                                                                size_t offset ,
                                                                                size_t length ,
                                                                                php_stream_mmap_operation_t mode ,
                                                                                size_t *mapped_len ) ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_userspace_dir_ops ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_userspace_ops ;
extern int __attribute__((__visibility__("default")))  _php_glob_stream_get_count(php_stream *stream ,
                                                                                  int *pflags ) ;
extern char __attribute__((__visibility__("default")))  *_php_glob_stream_get_pattern(php_stream *stream ,
                                                                                      int copy ,
                                                                                      int *plen ) ;
extern char __attribute__((__visibility__("default")))  *_php_glob_stream_get_path(php_stream *stream ,
                                                                                   int copy ,
                                                                                   int *plen ) ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_glob_stream_ops ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_glob_stream_wrapper ;
extern FILE __attribute__((__visibility__("default")))  *_php_stream_open_wrapper_as_file(char *path ,
                                                                                          char *mode ,
                                                                                          int options ,
                                                                                          char **opened_path ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_temporary_file(char const   *dir ,
                                                                                                char const   *pfx ,
                                                                                                char **opened_path ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_tmpfile(int dummy ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_from_pipe(FILE *file ,
                                                                                           char const   *mode ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_from_fd(int fd ,
                                                                                         char const   *mode ,
                                                                                         char const   *persistent_id ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_from_file(FILE *file ,
                                                                                           char const   *mode ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_with_path(char *filename ,
                                                                                           char *mode ,
                                                                                           char *path ,
                                                                                           char **opened_path ,
                                                                                           int options ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen(char const   *filename ,
                                                                                 char const   *mode ,
                                                                                 char **opened_path ,
                                                                                 int options ) ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_plain_files_wrapper ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_stdio_ops ;
struct timeval;
typedef php_stream *php_stream_transport_factory_func(char const   *proto ,
                                                      long protolen ,
                                                      char *resourcename ,
                                                      long resourcenamelen ,
                                                      char const   *persistent_id ,
                                                      int options , int flags ,
                                                      struct timeval *timeout ,
                                                      php_stream_context *context );
extern php_stream_transport_factory_func __attribute__((__visibility__("default")))  php_stream_generic_socket_factory ;
extern HashTable __attribute__((__visibility__("default")))  *php_stream_xport_get_hash(void) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_crypto_enable(php_stream *stream ,
                                                                                      int activate ) ;
enum __anonenum_php_stream_xport_crypt_method_t_72;
typedef enum __anonenum_php_stream_xport_crypt_method_t_72 php_stream_xport_crypt_method_t;
extern int __attribute__((__visibility__("default")))  php_stream_xport_crypto_setup(php_stream *stream ,
                                                                                     php_stream_xport_crypt_method_t crypto_method ,
                                                                                     php_stream *session_stream ) ;
enum __anonenum_stream_shutdown_t_68;
typedef enum __anonenum_stream_shutdown_t_68 stream_shutdown_t;
extern int __attribute__((__visibility__("default")))  php_stream_xport_shutdown(php_stream *stream ,
                                                                                 stream_shutdown_t how ) ;
typedef unsigned int __socklen_t;
typedef __socklen_t socklen_t;
extern int __attribute__((__visibility__("default")))  php_stream_xport_sendto(php_stream *stream ,
                                                                               char const   *buf ,
                                                                               size_t buflen ,
                                                                               long flags ,
                                                                               void *addr ,
                                                                               socklen_t addrlen ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_recvfrom(php_stream *stream ,
                                                                                 char *buf ,
                                                                                 size_t buflen ,
                                                                                 long flags ,
                                                                                 void **addr ,
                                                                                 socklen_t *addrlen ,
                                                                                 char **textaddr ,
                                                                                 int *textaddrlen ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_get_name(php_stream *stream ,
                                                                                 int want_peer ,
                                                                                 char **textaddr ,
                                                                                 int *textaddrlen ,
                                                                                 void **addr ,
                                                                                 socklen_t *addrlen ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_accept(php_stream *stream ,
                                                                               php_stream **client ,
                                                                               char **textaddr ,
                                                                               int *textaddrlen ,
                                                                               void **addr ,
                                                                               socklen_t *addrlen ,
                                                                               struct timeval *timeout ,
                                                                               char **error_text ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_listen(php_stream *stream ,
                                                                               int backlog ,
                                                                               char **error_text ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_connect(php_stream *stream ,
                                                                                char const   *name ,
                                                                                long namelen ,
                                                                                int asynchronous ,
                                                                                struct timeval *timeout ,
                                                                                char **error_text ,
                                                                                int *error_code ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_bind(php_stream *stream ,
                                                                             char const   *name ,
                                                                             long namelen ,
                                                                             char **error_text ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_xport_create(char const   *name ,
                                                                                        long namelen ,
                                                                                        int options ,
                                                                                        int flags ,
                                                                                        char const   *persistent_id ,
                                                                                        struct timeval *timeout ,
                                                                                        php_stream_context *context ,
                                                                                        char **error_string ,
                                                                                        int *error_code ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_unregister(char *protocol ) ;
typedef php_stream_transport_factory_func *php_stream_transport_factory;
extern int __attribute__((__visibility__("default")))  php_stream_xport_register(char *protocol ,
                                                                                 php_stream_transport_factory factory ) ;
extern  __attribute__((__nothrow__)) int isfdtype(int __fd , int __fdtype ) ;
extern  __attribute__((__nothrow__)) int sockatmark(int __fd ) ;
extern  __attribute__((__nothrow__)) int shutdown(int __fd , int __how ) ;
struct sockaddr;
extern int accept4(int __fd , struct sockaddr * __restrict  __addr ,
                   socklen_t * __restrict  __addr_len , int __flags ) ;
extern int accept(int __fd , struct sockaddr * __restrict  __addr ,
                  socklen_t * __restrict  __addr_len ) ;
extern  __attribute__((__nothrow__)) int listen(int __fd , int __n ) ;
extern  __attribute__((__nothrow__)) int setsockopt(int __fd , int __level ,
                                                    int __optname ,
                                                    void const   *__optval ,
                                                    socklen_t __optlen ) ;
extern  __attribute__((__nothrow__)) int getsockopt(int __fd , int __level ,
                                                    int __optname ,
                                                    void * __restrict  __optval ,
                                                    socklen_t * __restrict  __optlen ) ;
struct msghdr;
typedef __ssize_t ssize_t;
extern ssize_t recvmsg(int __fd , struct msghdr *__message , int __flags ) ;
extern ssize_t sendmsg(int __fd , struct msghdr  const  *__message ,
                       int __flags ) ;
extern ssize_t recvfrom(int __fd , void * __restrict  __buf , size_t __n ,
                        int __flags , struct sockaddr * __restrict  __addr ,
                        socklen_t * __restrict  __addr_len ) ;
extern ssize_t sendto(int __fd , void const   *__buf , size_t __n ,
                      int __flags ,
                      struct sockaddr  const  * __restrict  __addr ,
                      socklen_t __addr_len ) ;
extern ssize_t recv(int __fd , void *__buf , size_t __n , int __flags ) ;
extern ssize_t send(int __fd , void const   *__buf , size_t __n , int __flags ) ;
extern  __attribute__((__nothrow__)) int getpeername(int __fd ,
                                                     struct sockaddr * __restrict  __addr ,
                                                     socklen_t * __restrict  __len ) ;
extern int connect(int __fd , struct sockaddr  const  * __restrict  __addr ,
                   socklen_t __len ) ;
extern  __attribute__((__nothrow__)) int getsockname(int __fd ,
                                                     struct sockaddr * __restrict  __addr ,
                                                     socklen_t * __restrict  __len ) ;
extern  __attribute__((__nothrow__)) int bind(int __fd ,
                                              struct sockaddr  const  * __restrict  __addr ,
                                              socklen_t __len ) ;
extern  __attribute__((__nothrow__)) int socketpair(int __domain , int __type ,
                                                    int __protocol , int *__fds ) ;
extern  __attribute__((__nothrow__)) int socket(int __domain , int __type ,
                                                int __protocol ) ;
struct mmsghdr;
extern int recvmmsg(int __fd , struct mmsghdr *__vmessages ,
                    unsigned int __vlen , int __flags ,
                    struct timespec  const  *__tmo ) ;
struct cmsghdr;
struct iovec;
struct msghdr {
   void *msg_name ;
   socklen_t msg_namelen ;
   struct iovec *msg_iov ;
   size_t msg_iovlen ;
   void *msg_control ;
   size_t msg_controllen ;
   int msg_flags ;
};
struct cmsghdr {
   size_t cmsg_len ;
   int cmsg_level ;
   int cmsg_type ;
   unsigned char __cmsg_data[] ;
};
__inline extern  __attribute__((__nothrow__)) struct cmsghdr *__cmsg_nxthdr(struct msghdr *__mhdr ,
                                                                            struct cmsghdr *__cmsg ) ;
__inline extern struct cmsghdr *__cmsg_nxthdr(struct msghdr *__mhdr ,
                                              struct cmsghdr *__cmsg ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1132\n");
  fflush(_coverage_fout);
  }
  if (__cmsg->cmsg_len < sizeof(struct cmsghdr )) {
    {
    fprintf(_coverage_fout, "1126\n");
    fflush(_coverage_fout);
    }
    return ((struct cmsghdr *)0);
  } else {
    {
    fprintf(_coverage_fout, "1127\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1133\n");
  fflush(_coverage_fout);
  }
  __cmsg = (struct cmsghdr *)((unsigned char *)__cmsg + (((__cmsg->cmsg_len + sizeof(size_t )) - 1U) & ~ (sizeof(size_t ) - 1U)));
  {
  fprintf(_coverage_fout, "1134\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )((unsigned char *)(__cmsg + 1)) > (unsigned int )((unsigned char *)__mhdr->msg_control + __mhdr->msg_controllen)) {
    {
    fprintf(_coverage_fout, "1128\n");
    fflush(_coverage_fout);
    }
    return ((struct cmsghdr *)0);
  } else {
    {
    fprintf(_coverage_fout, "1131\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )((unsigned char *)__cmsg + (((__cmsg->cmsg_len + sizeof(size_t )) - 1U) & ~ (sizeof(size_t ) - 1U))) > (unsigned int )((unsigned char *)__mhdr->msg_control + __mhdr->msg_controllen)) {
      {
      fprintf(_coverage_fout, "1129\n");
      fflush(_coverage_fout);
      }
      return ((struct cmsghdr *)0);
    } else {
      {
      fprintf(_coverage_fout, "1130\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "1135\n");
  fflush(_coverage_fout);
  }
  return (__cmsg);
}
}
__inline extern  __attribute__((__nothrow__)) struct cmsghdr *__cmsg_nxthdr(struct msghdr *__mhdr ,
                                                                            struct cmsghdr *__cmsg ) ;
extern ssize_t pwritev64(int __fd , struct iovec  const  *__iovec ,
                         int __count , __off64_t __offset ) ;
extern ssize_t preadv64(int __fd , struct iovec  const  *__iovec , int __count ,
                        __off64_t __offset ) ;
extern ssize_t pwritev(int __fd , struct iovec  const  *__iovec , int __count ,
                       __off_t __offset ) ;
extern ssize_t preadv(int __fd , struct iovec  const  *__iovec , int __count ,
                      __off_t __offset ) ;
extern ssize_t writev(int __fd , struct iovec  const  *__iovec , int __count ) ;
extern ssize_t readv(int __fd , struct iovec  const  *__iovec , int __count ) ;
extern size_t __attribute__((__visibility__("default")))  _php_stream_passthru(php_stream *src ) ;
extern size_t __attribute__((__visibility__("default")))  _php_stream_copy_to_mem(php_stream *src ,
                                                                                  char **buf ,
                                                                                  size_t maxlen ,
                                                                                  int persistent ) ;
extern size_t __attribute__((__visibility__("default")))  _php_stream_copy_to_stream_ex(php_stream *src ,
                                                                                        php_stream *dest ,
                                                                                        size_t maxlen ,
                                                                                        size_t *len ) ;
extern size_t __attribute__((__visibility__("default"),
__deprecated__))  _php_stream_copy_to_stream(php_stream *src ,
                                             php_stream *dest , size_t maxlen ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_truncate_set_size(php_stream *stream ,
                                                                                     size_t newsize ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_set_option(php_stream *stream ,
                                                                              int option ,
                                                                              int value ,
                                                                              void *ptrparam ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_scandir(char *dirname ,
                                                                           char ***namelist ,
                                                                           int flags ,
                                                                           php_stream_context *context ,
                                                                           int (*compare)(char const   **a ,
                                                                                          char const   **b ) ) ;
extern int __attribute__((__visibility__("default")))  php_stream_dirent_alphasortr(char const   **a ,
                                                                                    char const   **b ) ;
extern int __attribute__((__visibility__("default")))  php_stream_dirent_alphasort(char const   **a ,
                                                                                   char const   **b ) ;
struct _php_stream_dirent;
typedef struct _php_stream_dirent php_stream_dirent;
extern php_stream_dirent __attribute__((__visibility__("default")))  *_php_stream_readdir(php_stream *dirstream ,
                                                                                          php_stream_dirent *ent ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_opendir(char *path ,
                                                                                   int options ,
                                                                                   php_stream_context *context ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_rmdir(char *path ,
                                                                         int options ,
                                                                         php_stream_context *context ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_mkdir(char *path ,
                                                                         int mode ,
                                                                         int options ,
                                                                         php_stream_context *context ) ;
struct _php_stream_statbuf;
typedef struct _php_stream_statbuf php_stream_statbuf;
extern int __attribute__((__visibility__("default")))  _php_stream_stat_path(char *path ,
                                                                             int flags ,
                                                                             php_stream_statbuf *ssb ,
                                                                             php_stream_context *context ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_stat(php_stream *stream ,
                                                                        php_stream_statbuf *ssb ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_puts(php_stream *stream ,
                                                                        char *buf ) ;
extern char __attribute__((__visibility__("default")))  *php_stream_get_record(php_stream *stream ,
                                                                               size_t maxlen ,
                                                                               size_t *returned_len ,
                                                                               char *delim ,
                                                                               size_t delim_len ) ;
extern char __attribute__((__visibility__("default")))  *_php_stream_get_line(php_stream *stream ,
                                                                              char *buf ,
                                                                              size_t maxlen ,
                                                                              size_t *returned_len ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_flush(php_stream *stream ,
                                                                         int closing ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_putc(php_stream *stream ,
                                                                        int c ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_getc(php_stream *stream ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_eof(php_stream *stream ) ;
extern size_t __attribute__((__visibility__("default")))  ( /* format attribute */  _php_stream_printf)(php_stream *stream ,
                                                                                                        char const   *fmt 
                                                                                                        , ...) ;
extern size_t __attribute__((__visibility__("default")))  _php_stream_write(php_stream *stream ,
                                                                            char const   *buf ,
                                                                            size_t count ) ;
extern size_t __attribute__((__visibility__("default")))  _php_stream_read(php_stream *stream ,
                                                                           char *buf ,
                                                                           size_t count ) ;
extern off_t __attribute__((__visibility__("default")))  _php_stream_tell(php_stream *stream ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_seek(php_stream *stream ,
                                                                        off_t offset ,
                                                                        int whence ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_free(php_stream *stream ,
                                                                        int close_options ) ;
extern int __attribute__((__visibility__("default")))  php_stream_from_persistent_id(char const   *persistent_id ,
                                                                                     php_stream **stream ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_free_enclosed(php_stream *stream_enclosed ,
                                                                                 int close_options ) ;
extern php_stream __attribute__((__visibility__("default")))  *php_stream_encloses(php_stream *enclosing ,
                                                                                   php_stream *enclosed ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_alloc(php_stream_ops *ops ,
                                                                                 void *abstract ,
                                                                                 char const   *persistent_id ,
                                                                                 char const   *mode ) ;
struct _php_stream_filter;
typedef struct _php_stream_filter php_stream_filter;
extern php_stream_filter __attribute__((__visibility__("default")))  *php_stream_filter_create(char const   *filtername ,
                                                                                               zval *filterparams ,
                                                                                               int persistent ) ;
struct _php_stream_filter_factory;
typedef struct _php_stream_filter_factory php_stream_filter_factory;
extern int __attribute__((__visibility__("default")))  php_stream_filter_register_factory_volatile(char const   *filterpattern ,
                                                                                                   php_stream_filter_factory *factory ) ;
extern int __attribute__((__visibility__("default")))  php_stream_filter_unregister_factory(char const   *filterpattern ) ;
extern int __attribute__((__visibility__("default")))  php_stream_filter_register_factory(char const   *filterpattern ,
                                                                                          php_stream_filter_factory *factory ) ;
struct _php_stream_filter_ops;
typedef struct _php_stream_filter_ops php_stream_filter_ops;
extern php_stream_filter __attribute__((__visibility__("default")))  *_php_stream_filter_alloc(php_stream_filter_ops *fops ,
                                                                                               void *abstract ,
                                                                                               int persistent ) ;
extern void __attribute__((__visibility__("default")))  php_stream_filter_free(php_stream_filter *filter ) ;
extern php_stream_filter __attribute__((__visibility__("default")))  *php_stream_filter_remove(php_stream_filter *filter ,
                                                                                               int call_dtor ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_filter_flush(php_stream_filter *filter ,
                                                                                int finish ) ;
struct _php_stream_filter_chain;
typedef struct _php_stream_filter_chain php_stream_filter_chain;
extern int __attribute__((__visibility__("default")))  php_stream_filter_append_ex(php_stream_filter_chain *chain ,
                                                                                   php_stream_filter *filter ) ;
extern void __attribute__((__visibility__("default")))  _php_stream_filter_append(php_stream_filter_chain *chain ,
                                                                                  php_stream_filter *filter ) ;
extern int __attribute__((__visibility__("default")))  php_stream_filter_prepend_ex(php_stream_filter_chain *chain ,
                                                                                    php_stream_filter *filter ) ;
extern void __attribute__((__visibility__("default")))  _php_stream_filter_prepend(php_stream_filter_chain *chain ,
                                                                                   php_stream_filter *filter ) ;
struct _php_stream_bucket;
typedef struct _php_stream_bucket php_stream_bucket;
extern php_stream_bucket __attribute__((__visibility__("default")))  *php_stream_bucket_make_writeable(php_stream_bucket *bucket ) ;
extern void __attribute__((__visibility__("default")))  php_stream_bucket_unlink(php_stream_bucket *bucket ) ;
struct _php_stream_bucket_brigade;
typedef struct _php_stream_bucket_brigade php_stream_bucket_brigade;
extern void __attribute__((__visibility__("default")))  php_stream_bucket_append(php_stream_bucket_brigade *brigade ,
                                                                                 php_stream_bucket *bucket ) ;
extern void __attribute__((__visibility__("default")))  php_stream_bucket_prepend(php_stream_bucket_brigade *brigade ,
                                                                                  php_stream_bucket *bucket ) ;
extern void __attribute__((__visibility__("default")))  php_stream_bucket_delref(php_stream_bucket *bucket ) ;
extern int __attribute__((__visibility__("default")))  php_stream_bucket_split(php_stream_bucket *in ,
                                                                               php_stream_bucket **left ,
                                                                               php_stream_bucket **right ,
                                                                               size_t length ) ;
extern php_stream_bucket __attribute__((__visibility__("default")))  *php_stream_bucket_new(php_stream *stream ,
                                                                                            char *buf ,
                                                                                            size_t buflen ,
                                                                                            int own_buf ,
                                                                                            int buf_persistent ) ;
extern php_stream_context __attribute__((__visibility__("default")))  *php_stream_context_set(php_stream *stream ,
                                                                                              php_stream_context *context ) ;
extern void __attribute__((__visibility__("default")))  php_stream_notification_notify(php_stream_context *context ,
                                                                                       int notifycode ,
                                                                                       int severity ,
                                                                                       char *xmsg ,
                                                                                       int xcode ,
                                                                                       size_t bytes_sofar ,
                                                                                       size_t bytes_max ,
                                                                                       void *ptr ) ;
struct _php_stream_notifier;
typedef struct _php_stream_notifier php_stream_notifier;
extern void __attribute__((__visibility__("default")))  php_stream_notification_free(php_stream_notifier *notifier ) ;
extern php_stream_notifier __attribute__((__visibility__("default")))  *php_stream_notification_alloc(void) ;
extern int __attribute__((__visibility__("default")))  php_stream_context_del_link(php_stream_context *context ,
                                                                                   php_stream *stream ) ;
extern int __attribute__((__visibility__("default")))  php_stream_context_set_link(php_stream_context *context ,
                                                                                   char const   *hostent ,
                                                                                   php_stream *stream ) ;
extern int __attribute__((__visibility__("default")))  php_stream_context_get_link(php_stream_context *context ,
                                                                                   char const   *hostent ,
                                                                                   php_stream **stream ) ;
extern int __attribute__((__visibility__("default")))  php_stream_context_set_option(php_stream_context *context ,
                                                                                     char const   *wrappername ,
                                                                                     char const   *optionname ,
                                                                                     zval *optionvalue ) ;
extern int __attribute__((__visibility__("default")))  php_stream_context_get_option(php_stream_context *context ,
                                                                                     char const   *wrappername ,
                                                                                     char const   *optionname ,
                                                                                     zval ***optionvalue ) ;
extern php_stream_context __attribute__((__visibility__("default")))  *php_stream_context_alloc(void) ;
extern void __attribute__((__visibility__("default")))  php_stream_context_free(php_stream_context *context ) ;
extern int __attribute__((__visibility__("default")))  php_file_le_stream_filter(void) ;
extern int __attribute__((__visibility__("default")))  php_file_le_pstream(void) ;
extern int __attribute__((__visibility__("default")))  php_file_le_stream(void) ;
struct stat64;
extern  __attribute__((__nothrow__)) int __fxstatat64(int __ver , int __fildes ,
                                                      char const   *__filename ,
                                                      struct stat64 *__stat_buf ,
                                                      int __flag )  __attribute__((__nonnull__(3,4))) ;
__inline extern  __attribute__((__nothrow__)) int fstatat64(int __fd ,
                                                            char const   * __restrict  __filename ,
                                                            struct stat64 * __restrict  __statbuf ,
                                                            int __flag )  __attribute__((__nonnull__(2,3))) ;
__inline extern int fstatat64(int __fd , char const   * __restrict  __filename ,
                              struct stat64 * __restrict  __statbuf ,
                              int __flag ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1124\n");
  fflush(_coverage_fout);
  }
  tmp = __fxstatat64(3, __fd, (char const   *)__filename,
                     (struct stat64 *)__statbuf, __flag);
  {
  fprintf(_coverage_fout, "1125\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstatat64(int __fd ,
                                                            char const   * __restrict  __filename ,
                                                            struct stat64 * __restrict  __statbuf ,
                                                            int __flag )  __attribute__((__nonnull__(2,3))) ;
extern  __attribute__((__nothrow__)) int __fxstat64(int __ver , int __fildes ,
                                                    struct stat64 *__stat_buf )  __attribute__((__nonnull__(3))) ;
__inline extern  __attribute__((__nothrow__)) int fstat64(int __fd ,
                                                          struct stat64 *__statbuf )  __attribute__((__nonnull__(2))) ;
__inline extern int fstat64(int __fd , struct stat64 *__statbuf ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1122\n");
  fflush(_coverage_fout);
  }
  tmp = __fxstat64(3, __fd, __statbuf);
  {
  fprintf(_coverage_fout, "1123\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstat64(int __fd ,
                                                          struct stat64 *__statbuf )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int __lxstat64(int __ver ,
                                                    char const   *__filename ,
                                                    struct stat64 *__stat_buf )  __attribute__((__nonnull__(2,3))) ;
__inline extern  __attribute__((__nothrow__)) int lstat64(char const   * __restrict  __path ,
                                                          struct stat64 * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int lstat64(char const   * __restrict  __path ,
                            struct stat64 * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1120\n");
  fflush(_coverage_fout);
  }
  tmp = __lxstat64(3, (char const   *)__path, (struct stat64 *)__statbuf);
  {
  fprintf(_coverage_fout, "1121\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int lstat64(char const   * __restrict  __path ,
                                                          struct stat64 * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int __xstat64(int __ver ,
                                                   char const   *__filename ,
                                                   struct stat64 *__stat_buf )  __attribute__((__nonnull__(2,3))) ;
__inline extern  __attribute__((__nothrow__)) int stat64(char const   * __restrict  __path ,
                                                         struct stat64 * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int stat64(char const   * __restrict  __path ,
                           struct stat64 * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1118\n");
  fflush(_coverage_fout);
  }
  tmp = __xstat64(3, (char const   *)__path, (struct stat64 *)__statbuf);
  {
  fprintf(_coverage_fout, "1119\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int stat64(char const   * __restrict  __path ,
                                                         struct stat64 * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
typedef unsigned long long __u_quad_t;
typedef __u_quad_t __dev_t;
extern  __attribute__((__nothrow__)) int __xmknodat(int __ver , int __fd ,
                                                    char const   *__path ,
                                                    __mode_t __mode ,
                                                    __dev_t *__dev )  __attribute__((__nonnull__(3,5))) ;
__inline extern  __attribute__((__nothrow__)) int mknodat(int __fd ,
                                                          char const   *__path ,
                                                          __mode_t __mode ,
                                                          __dev_t __dev )  __attribute__((__nonnull__(2))) ;
__inline extern int mknodat(int __fd , char const   *__path , __mode_t __mode ,
                            __dev_t __dev ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1116\n");
  fflush(_coverage_fout);
  }
  tmp = __xmknodat(1, __fd, __path, __mode, & __dev);
  {
  fprintf(_coverage_fout, "1117\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int mknodat(int __fd ,
                                                          char const   *__path ,
                                                          __mode_t __mode ,
                                                          __dev_t __dev )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int __xmknod(int __ver ,
                                                  char const   *__path ,
                                                  __mode_t __mode ,
                                                  __dev_t *__dev )  __attribute__((__nonnull__(2,4))) ;
__inline extern  __attribute__((__nothrow__)) int mknod(char const   *__path ,
                                                        __mode_t __mode ,
                                                        __dev_t __dev )  __attribute__((__nonnull__(1))) ;
__inline extern int mknod(char const   *__path , __mode_t __mode ,
                          __dev_t __dev ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1114\n");
  fflush(_coverage_fout);
  }
  tmp = __xmknod(1, __path, __mode, & __dev);
  {
  fprintf(_coverage_fout, "1115\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int mknod(char const   *__path ,
                                                        __mode_t __mode ,
                                                        __dev_t __dev )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int __fxstatat(int __ver , int __fildes ,
                                                    char const   *__filename ,
                                                    struct stat *__stat_buf ,
                                                    int __flag )  __attribute__((__nonnull__(3,4))) ;
__inline extern  __attribute__((__nothrow__)) int fstatat(int __fd ,
                                                          char const   * __restrict  __filename ,
                                                          struct stat * __restrict  __statbuf ,
                                                          int __flag )  __attribute__((__nonnull__(2,3))) ;
__inline extern int fstatat(int __fd , char const   * __restrict  __filename ,
                            struct stat * __restrict  __statbuf , int __flag ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1112\n");
  fflush(_coverage_fout);
  }
  tmp = __fxstatat(3, __fd, (char const   *)__filename,
                   (struct stat *)__statbuf, __flag);
  {
  fprintf(_coverage_fout, "1113\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstatat(int __fd ,
                                                          char const   * __restrict  __filename ,
                                                          struct stat * __restrict  __statbuf ,
                                                          int __flag )  __attribute__((__nonnull__(2,3))) ;
extern  __attribute__((__nothrow__)) int __fxstat(int __ver , int __fildes ,
                                                  struct stat *__stat_buf )  __attribute__((__nonnull__(3))) ;
__inline extern  __attribute__((__nothrow__)) int fstat(int __fd ,
                                                        struct stat *__statbuf )  __attribute__((__nonnull__(2))) ;
__inline extern int fstat(int __fd , struct stat *__statbuf ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1110\n");
  fflush(_coverage_fout);
  }
  tmp = __fxstat(3, __fd, __statbuf);
  {
  fprintf(_coverage_fout, "1111\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstat(int __fd ,
                                                        struct stat *__statbuf )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int __lxstat(int __ver ,
                                                  char const   *__filename ,
                                                  struct stat *__stat_buf )  __attribute__((__nonnull__(2,3))) ;
__inline extern  __attribute__((__nothrow__)) int lstat(char const   * __restrict  __path ,
                                                        struct stat * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int lstat(char const   * __restrict  __path ,
                          struct stat * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1108\n");
  fflush(_coverage_fout);
  }
  tmp = __lxstat(3, (char const   *)__path, (struct stat *)__statbuf);
  {
  fprintf(_coverage_fout, "1109\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int lstat(char const   * __restrict  __path ,
                                                        struct stat * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int __xstat(int __ver ,
                                                 char const   *__filename ,
                                                 struct stat *__stat_buf )  __attribute__((__nonnull__(2,3))) ;
__inline extern  __attribute__((__nothrow__)) int stat(char const   * __restrict  __path ,
                                                       struct stat * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int stat(char const   * __restrict  __path ,
                         struct stat * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1106\n");
  fflush(_coverage_fout);
  }
  tmp = __xstat(3, (char const   *)__path, (struct stat *)__statbuf);
  {
  fprintf(_coverage_fout, "1107\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int stat(char const   * __restrict  __path ,
                                                       struct stat * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int futimens(int __fd ,
                                                  struct timespec  const  *__times ) ;
extern  __attribute__((__nothrow__)) int utimensat(int __fd ,
                                                   char const   *__path ,
                                                   struct timespec  const  *__times ,
                                                   int __flags )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int mkfifoat(int __fd ,
                                                  char const   *__path ,
                                                  __mode_t __mode )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int mkfifo(char const   *__path ,
                                                __mode_t __mode )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int mkdirat(int __fd ,
                                                 char const   *__path ,
                                                 __mode_t __mode )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int mkdir(char const   *__path ,
                                               __mode_t __mode )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) __mode_t getumask(void) ;
extern  __attribute__((__nothrow__)) __mode_t umask(__mode_t __mask ) ;
extern  __attribute__((__nothrow__)) int fchmodat(int __fd ,
                                                  char const   *__file ,
                                                  __mode_t __mode , int __flag )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int fchmod(int __fd , __mode_t __mode ) ;
extern  __attribute__((__nothrow__)) int lchmod(char const   *__file ,
                                                __mode_t __mode )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int chmod(char const   *__file ,
                                               __mode_t __mode )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int futimesat(int __fd ,
                                                   char const   *__file ,
                                                   struct timeval  const  *__tvp ) ;
extern  __attribute__((__nothrow__)) int futimes(int __fd ,
                                                 struct timeval  const  *__tvp ) ;
extern  __attribute__((__nothrow__)) int lutimes(char const   *__file ,
                                                 struct timeval  const  *__tvp )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int utimes(char const   *__file ,
                                                struct timeval  const  *__tvp )  __attribute__((__nonnull__(1))) ;
struct itimerval;
enum __itimer_which;
typedef enum __itimer_which __itimer_which_t;
extern  __attribute__((__nothrow__)) int setitimer(__itimer_which_t __which ,
                                                   struct itimerval  const  * __restrict  __new ,
                                                   struct itimerval * __restrict  __old ) ;
extern  __attribute__((__nothrow__)) int getitimer(__itimer_which_t __which ,
                                                   struct itimerval *__value ) ;
extern  __attribute__((__nothrow__)) int adjtime(struct timeval  const  *__delta ,
                                                 struct timeval *__olddelta ) ;
struct timezone;
extern  __attribute__((__nothrow__)) int settimeofday(struct timeval  const  *__tv ,
                                                      struct timezone  const  *__tz )  __attribute__((__nonnull__(1))) ;
typedef struct timezone * __restrict  __timezone_ptr_t;
extern  __attribute__((__nothrow__)) int gettimeofday(struct timeval * __restrict  __tv ,
                                                      __timezone_ptr_t __tz )  __attribute__((__nonnull__(1))) ;
extern void zif_output_reset_rewrite_vars(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern void zif_output_add_rewrite_var(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_ob_list_handlers(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_ob_implicit_flush(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void zif_ob_get_status(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_ob_get_level(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_ob_get_length(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_ob_get_contents(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
extern void zif_ob_get_clean(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_ob_get_flush(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_ob_end_clean(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_ob_end_flush(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_ob_clean(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_ob_flush(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_ob_start(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
struct _php_output_handler;
extern int __attribute__((__visibility__("default")))  php_output_handler_alias_register(char const   *handler_name ,
                                                                                         size_t handler_name_len ,
                                                                                         struct _php_output_handler *(*func)(char const   *handler_name ,
                                                                                                                             size_t handler_name_len ,
                                                                                                                             size_t chunk_size ,
                                                                                                                             int flags ) ) ;
typedef struct _php_output_handler *(*php_output_handler_alias_ctor_t)(char const   *handler_name ,
                                                                       size_t handler_name_len ,
                                                                       size_t chunk_size ,
                                                                       int flags );
extern php_output_handler_alias_ctor_t __attribute__((__visibility__("default")))  *php_output_handler_alias(char const   *handler_name ,
                                                                                                             size_t handler_name_len ) ;
extern int __attribute__((__visibility__("default")))  php_output_handler_reverse_conflict_register(char const   *handler_name ,
                                                                                                    size_t handler_name_len ,
                                                                                                    int (*check_func)(char const   *handler_name ,
                                                                                                                      size_t handler_name_len ) ) ;
extern int __attribute__((__visibility__("default")))  php_output_handler_conflict_register(char const   *handler_name ,
                                                                                            size_t handler_name_len ,
                                                                                            int (*check_func)(char const   *handler_name ,
                                                                                                              size_t handler_name_len ) ) ;
extern int __attribute__((__visibility__("default")))  php_output_handler_conflict(char const   *handler_new ,
                                                                                   size_t handler_new_len ,
                                                                                   char const   *handler_set ,
                                                                                   size_t handler_set_len ) ;
typedef struct _php_output_handler php_output_handler;
extern void __attribute__((__visibility__("default")))  php_output_handler_free(php_output_handler **handler ) ;
extern void __attribute__((__visibility__("default")))  php_output_handler_dtor(php_output_handler *handler ) ;
enum _php_output_handler_hook_t;
typedef enum _php_output_handler_hook_t php_output_handler_hook_t;
extern int __attribute__((__visibility__("default")))  php_output_handler_hook(php_output_handler_hook_t type ,
                                                                               void *arg ) ;
extern int __attribute__((__visibility__("default")))  php_output_handler_started(char const   *name ,
                                                                                  size_t name_len ) ;
extern int __attribute__((__visibility__("default")))  php_output_handler_start(php_output_handler *handler ) ;
extern void __attribute__((__visibility__("default")))  php_output_handler_set_context(php_output_handler *handler ,
                                                                                       void *opaq ,
                                                                                       void (*dtor)(void * ) ) ;
struct _php_output_context;
typedef struct _php_output_context php_output_context;
extern php_output_handler __attribute__((__visibility__("default")))  *php_output_handler_create_internal(char const   *name ,
                                                                                                          size_t name_len ,
                                                                                                          int (*handler)(void **handler_context ,
                                                                                                                         php_output_context *output_context ) ,
                                                                                                          size_t chunk_size ,
                                                                                                          int flags ) ;
extern php_output_handler __attribute__((__visibility__("default")))  *php_output_handler_create_user(zval *handler ,
                                                                                                      size_t chunk_size ,
                                                                                                      int flags ) ;
extern int __attribute__((__visibility__("default")))  php_output_start_internal(char const   *name ,
                                                                                 size_t name_len ,
                                                                                 void (*output_handler)(char *output ,
                                                                                                        uint output_len ,
                                                                                                        char **handled_output ,
                                                                                                        uint *handled_output_len ,
                                                                                                        int mode ) ,
                                                                                 size_t chunk_size ,
                                                                                 int flags ) ;
extern int __attribute__((__visibility__("default")))  php_output_start_user(zval *output_handler ,
                                                                             size_t chunk_size ,
                                                                             int flags ) ;
extern int __attribute__((__visibility__("default")))  php_output_start_devnull(void) ;
extern int __attribute__((__visibility__("default")))  php_output_start_default(void) ;
extern int __attribute__((__visibility__("default")))  php_output_get_level(void) ;
extern int __attribute__((__visibility__("default")))  php_output_get_length(zval *p ) ;
extern int __attribute__((__visibility__("default")))  php_output_get_contents(zval *p ) ;
extern void __attribute__((__visibility__("default")))  php_output_discard_all(void) ;
extern int __attribute__((__visibility__("default")))  php_output_discard(void) ;
extern void __attribute__((__visibility__("default")))  php_output_end_all(void) ;
extern int __attribute__((__visibility__("default")))  php_output_end(void) ;
extern void __attribute__((__visibility__("default")))  php_output_clean_all(void) ;
extern int __attribute__((__visibility__("default")))  php_output_clean(void) ;
extern void __attribute__((__visibility__("default")))  php_output_flush_all(void) ;
extern int __attribute__((__visibility__("default")))  php_output_flush(void) ;
extern int __attribute__((__visibility__("default")))  php_output_write(char const   *str ,
                                                                        size_t len ) ;
extern int __attribute__((__visibility__("default")))  php_output_write_unbuffered(char const   *str ,
                                                                                   size_t len ) ;
extern int __attribute__((__visibility__("default")))  php_output_get_start_lineno(void) ;
extern char __attribute__((__visibility__("default")))  *php_output_get_start_filename(void) ;
extern void __attribute__((__visibility__("default")))  php_output_set_implicit_flush(int flush ) ;
extern int __attribute__((__visibility__("default")))  php_output_get_status(void) ;
extern void __attribute__((__visibility__("default")))  php_output_set_status(int status ) ;
extern void __attribute__((__visibility__("default")))  php_output_deactivate(void) ;
extern int __attribute__((__visibility__("default")))  php_output_activate(void) ;
extern void __attribute__((__visibility__("default")))  php_output_register_constants(void) ;
extern void __attribute__((__visibility__("default")))  php_output_shutdown(void) ;
extern void __attribute__((__visibility__("default")))  php_output_startup(void) ;
extern char const   php_output_devnull_handler_name[sizeof("null output handler")] ;
extern char const   php_output_default_handler_name[sizeof("default output handler")] ;
extern char __attribute__((__visibility__("default")))  *php_get_current_user(void) ;
extern void __attribute__((__visibility__("default")))  php_com_initialize(void) ;
extern void __attribute__((__visibility__("default")))  php_register_pre_request_shutdown(void (*func)(void * ) ,
                                                                                          void *userdata ) ;
extern int __attribute__((__visibility__("default")))  php_mergesort(void *base ,
                                                                     size_t nmemb ,
                                                                     size_t size ,
                                                                     int (*cmp)(void const   * ,
                                                                                void const   * ) ) ;
extern int __attribute__((__visibility__("default")))  php_register_internal_extensions(void) ;
extern int __attribute__((__visibility__("default")))  (*php_register_internal_extensions_func)(void) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  php_error_docref2)(char const   *docref ,
                                                                                                     char const   *param1 ,
                                                                                                     char const   *param2 ,
                                                                                                     int type ,
                                                                                                     char const   *format 
                                                                                                     , ...) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  php_error_docref1)(char const   *docref ,
                                                                                                     char const   *param1 ,
                                                                                                     int type ,
                                                                                                     char const   *format 
                                                                                                     , ...) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  php_verror)(char const   *docref ,
                                                                                              char const   *params ,
                                                                                              int type ,
                                                                                              char const   *format ,
                                                                                              va_list args ) ;
__inline static void __attribute__((__deprecated__))  php_std_error_handling(void) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1105\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void __attribute__((__deprecated__))  php_std_error_handling(void) ;
__inline static void __attribute__((__deprecated__))  php_set_error_handling(zend_error_handling_t error_handling ,
                                                                             zend_class_entry *exception_class ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1103\n");
  fflush(_coverage_fout);
  }
  zend_replace_error_handling(error_handling, exception_class,
                              (zend_error_handling *)((void *)0));
  {
  fprintf(_coverage_fout, "1104\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void __attribute__((__deprecated__))  php_set_error_handling(zend_error_handling_t error_handling ,
                                                                             zend_class_entry *exception_class ) ;
extern int cfgparse(void) ;
extern int ( /* format attribute */  Debug)(char *format  , ...) ;
extern void __attribute__((__visibility__("default")))  php_log_err(char *log_message ) ;
extern int __attribute__((__visibility__("default")))  ( /* format attribute */  php_printf)(char const   *format 
                                                                                             , ...) ;
extern int __attribute__((__visibility__("default")))  php_write(void *buf ,
                                                                 uint size ) ;
extern void phperror(char *error ) ;
extern int __attribute__((__visibility__("default")))  ( /* format attribute */  vspprintf)(char **pbuf ,
                                                                                            size_t max_len ,
                                                                                            char const   *format ,
                                                                                            va_list ap ) ;
extern int __attribute__((__visibility__("default")))  ( /* format attribute */  spprintf)(char **pbuf ,
                                                                                           size_t max_len ,
                                                                                           char const   *format 
                                                                                           , ...) ;
typedef unsigned long long u_wide_int;
extern char *ap_php_conv_p2(u_wide_int num , int nbits , char format ,
                            char *buf_end , int *len ) ;
typedef int bool_int;
typedef long long wide_int;
extern char *ap_php_conv_10(wide_int num , bool_int is_unsigned ,
                            bool_int *is_negative , char *buf_end , int *len ) ;
enum __anonenum_boolean_e_59;
typedef enum __anonenum_boolean_e_59 boolean_e;
extern char __attribute__((__visibility__("default")))  *php_conv_fp(char format ,
                                                                     double num ,
                                                                     boolean_e add_dp ,
                                                                     int precision ,
                                                                     char dec_point ,
                                                                     bool_int *is_negative ,
                                                                     char *buf ,
                                                                     int *len ) ;
extern char __attribute__((__visibility__("default")))  *php_gcvt(double value ,
                                                                  int ndigit ,
                                                                  char dec_point ,
                                                                  char exponent ,
                                                                  char *buf ) ;
extern int __attribute__((__visibility__("default")))  ( /* format attribute */  php_sprintf)(char *s ,
                                                                                              char const   *format 
                                                                                              , ...) ;
extern int __attribute__((__visibility__("default")))  ap_php_asprintf(char **buf ,
                                                                       char const   *format 
                                                                       , ...) ;
extern int __attribute__((__visibility__("default")))  ap_php_vasprintf(char **buf ,
                                                                        char const   *format ,
                                                                        va_list ap ) ;
extern int __attribute__((__visibility__("default")))  ap_php_vsnprintf(char * ,
                                                                        size_t  ,
                                                                        char const   * ,
                                                                        va_list ap ) ;
extern int __attribute__((__visibility__("default")))  ap_php_snprintf(char * ,
                                                                       size_t  ,
                                                                       char const   * 
                                                                       , ...) ;
extern int __attribute__((__visibility__("default")))  ap_php_vslprintf(char *buf ,
                                                                        size_t len ,
                                                                        char const   *format ,
                                                                        va_list ap ) ;
extern int __attribute__((__visibility__("default")))  ap_php_slprintf(char *buf ,
                                                                       size_t len ,
                                                                       char const   *format 
                                                                       , ...) ;
extern int getpw(__uid_t __uid , char *__buffer ) ;
struct passwd;
extern int fgetpwent_r(FILE * __restrict  __stream ,
                       struct passwd * __restrict  __resultbuf ,
                       char * __restrict  __buffer , size_t __buflen ,
                       struct passwd ** __restrict  __result ) ;
extern int getpwnam_r(char const   * __restrict  __name ,
                      struct passwd * __restrict  __resultbuf ,
                      char * __restrict  __buffer , size_t __buflen ,
                      struct passwd ** __restrict  __result ) ;
extern int getpwuid_r(__uid_t __uid , struct passwd * __restrict  __resultbuf ,
                      char * __restrict  __buffer , size_t __buflen ,
                      struct passwd ** __restrict  __result ) ;
extern int getpwent_r(struct passwd * __restrict  __resultbuf ,
                      char * __restrict  __buffer , size_t __buflen ,
                      struct passwd ** __restrict  __result ) ;
extern struct passwd *getpwnam(char const   *__name ) ;
extern struct passwd *getpwuid(__uid_t __uid ) ;
extern int putpwent(struct passwd  const  * __restrict  __p ,
                    FILE * __restrict  __f ) ;
extern struct passwd *fgetpwent(FILE *__stream ) ;
extern struct passwd *getpwent(void) ;
extern void endpwent(void) ;
extern void setpwent(void) ;
extern  __attribute__((__nothrow__)) void swab(void const   * __restrict  __from ,
                                               void * __restrict  __to ,
                                               ssize_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void encrypt(char *__block , int __edflag )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *crypt(char const   *__key ,
                                                 char const   *__salt )  __attribute__((__nonnull__(1,2))) ;
extern int fdatasync(int __fildes ) ;
extern int lockf64(int __fd , int __cmd , __off64_t __len ) ;
extern int lockf(int __fd , int __cmd , __off_t __len ) ;
extern  __attribute__((__nothrow__)) long syscall(long __sysno  , ...) ;
typedef int __intptr_t;
typedef __intptr_t intptr_t;
extern  __attribute__((__nothrow__)) void *sbrk(intptr_t __delta ) ;
extern  __attribute__((__nothrow__)) int brk(void *__addr ) ;
extern  __attribute__((__nothrow__)) int ftruncate64(int __fd ,
                                                     __off64_t __length ) ;
extern  __attribute__((__nothrow__)) int ftruncate(int __fd , __off_t __length ) ;
extern  __attribute__((__nothrow__)) int truncate64(char const   *__file ,
                                                    __off64_t __length )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int truncate(char const   *__file ,
                                                  __off_t __length )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int getdtablesize(void) ;
extern  __attribute__((__nothrow__)) int getpagesize(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) void sync(void) ;
extern long gethostid(void) ;
extern int fsync(int __fd ) ;
extern char *getpass(char const   *__prompt )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int chroot(char const   *__path )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int daemon(int __nochdir , int __noclose ) ;
extern  __attribute__((__nothrow__)) void setusershell(void) ;
extern  __attribute__((__nothrow__)) void endusershell(void) ;
extern  __attribute__((__nothrow__)) char *getusershell(void) ;
extern  __attribute__((__nothrow__)) int acct(char const   *__name ) ;
extern  __attribute__((__nothrow__)) int profil(unsigned short *__sample_buffer ,
                                                size_t __size ,
                                                size_t __offset ,
                                                unsigned int __scale )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int revoke(char const   *__file )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int vhangup(void) ;
extern  __attribute__((__nothrow__)) int setdomainname(char const   *__name ,
                                                       size_t __len )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int getdomainname(char *__name ,
                                                       size_t __len )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sethostid(long __id ) ;
extern  __attribute__((__nothrow__)) int sethostname(char const   *__name ,
                                                     size_t __len )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int gethostname(char *__name ,
                                                     size_t __len )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int getopt(int ___argc ,
                                                char * const  *___argv ,
                                                char const   *__shortopts ) ;
extern int optopt ;
extern int opterr ;
extern int optind ;
extern char *optarg ;
extern  __attribute__((__nothrow__)) int setlogin(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern int getlogin_r(char *__name , size_t __name_len )  __attribute__((__nonnull__(1))) ;
extern char *getlogin(void) ;
extern  __attribute__((__nothrow__)) int tcsetpgrp(int __fd , __pid_t __pgrp_id ) ;
extern  __attribute__((__nothrow__)) __pid_t tcgetpgrp(int __fd ) ;
extern  __attribute__((__nothrow__)) int rmdir(char const   *__path )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int unlinkat(int __fd ,
                                                  char const   *__name ,
                                                  int __flag )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int unlink(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) ssize_t readlinkat(int __fd ,
                                                        char const   * __restrict  __path ,
                                                        char * __restrict  __buf ,
                                                        size_t __len )  __attribute__((__nonnull__(2,3))) ;
extern  __attribute__((__nothrow__)) int symlinkat(char const   *__from ,
                                                   int __tofd ,
                                                   char const   *__to )  __attribute__((__nonnull__(1,3))) ;
extern  __attribute__((__nothrow__)) ssize_t readlink(char const   * __restrict  __path ,
                                                      char * __restrict  __buf ,
                                                      size_t __len )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int symlink(char const   *__from ,
                                                 char const   *__to )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int linkat(int __fromfd ,
                                                char const   *__from ,
                                                int __tofd ,
                                                char const   *__to ,
                                                int __flags )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) int link(char const   *__from ,
                                              char const   *__to )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int ttyslot(void) ;
extern  __attribute__((__nothrow__)) int isatty(int __fd ) ;
extern  __attribute__((__nothrow__)) int ttyname_r(int __fd , char *__buf ,
                                                   size_t __buflen )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *ttyname(int __fd ) ;
extern  __attribute__((__nothrow__)) __pid_t vfork(void) ;
extern  __attribute__((__nothrow__)) __pid_t fork(void) ;
extern  __attribute__((__nothrow__)) int setresgid(__gid_t __rgid ,
                                                   __gid_t __egid ,
                                                   __gid_t __sgid ) ;
extern  __attribute__((__nothrow__)) int setresuid(__uid_t __ruid ,
                                                   __uid_t __euid ,
                                                   __uid_t __suid ) ;
extern  __attribute__((__nothrow__)) int getresgid(__gid_t *__rgid ,
                                                   __gid_t *__egid ,
                                                   __gid_t *__sgid ) ;
extern  __attribute__((__nothrow__)) int getresuid(__uid_t *__ruid ,
                                                   __uid_t *__euid ,
                                                   __uid_t *__suid ) ;
extern  __attribute__((__nothrow__)) int setegid(__gid_t __gid ) ;
extern  __attribute__((__nothrow__)) int setregid(__gid_t __rgid ,
                                                  __gid_t __egid ) ;
extern  __attribute__((__nothrow__)) int setgid(__gid_t __gid ) ;
extern  __attribute__((__nothrow__)) int seteuid(__uid_t __uid ) ;
extern  __attribute__((__nothrow__)) int setreuid(__uid_t __ruid ,
                                                  __uid_t __euid ) ;
extern  __attribute__((__nothrow__)) int setuid(__uid_t __uid ) ;
extern  __attribute__((__nothrow__)) int group_member(__gid_t __gid ) ;
extern  __attribute__((__nothrow__)) int getgroups(int __size , __gid_t *__list ) ;
extern  __attribute__((__nothrow__)) __gid_t getegid(void) ;
extern  __attribute__((__nothrow__)) __gid_t getgid(void) ;
extern  __attribute__((__nothrow__)) __uid_t geteuid(void) ;
extern  __attribute__((__nothrow__)) __uid_t getuid(void) ;
extern  __attribute__((__nothrow__)) __pid_t getsid(__pid_t __pid ) ;
extern  __attribute__((__nothrow__)) __pid_t setsid(void) ;
extern  __attribute__((__nothrow__)) int setpgrp(void) ;
extern  __attribute__((__nothrow__)) int setpgid(__pid_t __pid , __pid_t __pgid ) ;
extern  __attribute__((__nothrow__)) __pid_t getpgid(__pid_t __pid ) ;
extern  __attribute__((__nothrow__)) __pid_t __getpgid(__pid_t __pid ) ;
extern  __attribute__((__nothrow__)) __pid_t getpgrp(void) ;
extern  __attribute__((__nothrow__)) __pid_t getppid(void) ;
extern  __attribute__((__nothrow__)) __pid_t getpid(void) ;
extern  __attribute__((__nothrow__)) size_t confstr(int __name , char *__buf ,
                                                    size_t __len ) ;
extern  __attribute__((__nothrow__)) long sysconf(int __name ) ;
extern  __attribute__((__nothrow__)) long fpathconf(int __fd , int __name ) ;
extern  __attribute__((__nothrow__)) long pathconf(char const   *__path ,
                                                   int __name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__noreturn__)) void _exit(int __status ) ;
extern  __attribute__((__nothrow__)) int nice(int __inc ) ;
extern  __attribute__((__nothrow__)) int execvpe(char const   *__file ,
                                                 char * const  *__argv ,
                                                 char * const  *__envp )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int execlp(char const   *__file ,
                                                char const   *__arg  , ...)  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int execvp(char const   *__file ,
                                                char * const  *__argv )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int execl(char const   *__path ,
                                               char const   *__arg  , ...)  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int execle(char const   *__path ,
                                                char const   *__arg  , ...)  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int execv(char const   *__path ,
                                               char * const  *__argv )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int fexecve(int __fd ,
                                                 char * const  *__argv ,
                                                 char * const  *__envp )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int execve(char const   *__path ,
                                                char * const  *__argv ,
                                                char * const  *__envp )  __attribute__((__nonnull__(1,2))) ;
extern char **environ ;
extern char **__environ ;
extern  __attribute__((__nothrow__)) int dup3(int __fd , int __fd2 ,
                                              int __flags ) ;
extern  __attribute__((__nothrow__)) int dup2(int __fd , int __fd2 ) ;
extern  __attribute__((__nothrow__)) int dup(int __fd ) ;
extern  __attribute__((__nothrow__)) char *getwd(char *__buf )  __attribute__((__nonnull__(1),
__deprecated__)) ;
extern  __attribute__((__nothrow__)) char *get_current_dir_name(void) ;
extern  __attribute__((__nothrow__)) int fchdir(int __fd ) ;
extern  __attribute__((__nothrow__)) int chdir(char const   *__path )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int fchownat(int __fd ,
                                                  char const   *__file ,
                                                  __uid_t __owner ,
                                                  __gid_t __group , int __flag )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int lchown(char const   *__file ,
                                                __uid_t __owner ,
                                                __gid_t __group )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int fchown(int __fd , __uid_t __owner ,
                                                __gid_t __group ) ;
extern  __attribute__((__nothrow__)) int chown(char const   *__file ,
                                               __uid_t __owner ,
                                               __gid_t __group )  __attribute__((__nonnull__(1))) ;
extern int pause(void) ;
typedef unsigned int __useconds_t;
extern int usleep(__useconds_t __useconds ) ;
extern  __attribute__((__nothrow__)) __useconds_t ualarm(__useconds_t __value ,
                                                         __useconds_t __interval ) ;
extern unsigned int sleep(unsigned int __seconds ) ;
extern  __attribute__((__nothrow__)) unsigned int alarm(unsigned int __seconds ) ;
extern  __attribute__((__nothrow__)) int pipe2(int *__pipedes , int __flags ) ;
extern  __attribute__((__nothrow__)) int pipe(int *__pipedes ) ;
extern ssize_t pwrite64(int __fd , void const   *__buf , size_t __n ,
                        __off64_t __offset ) ;
extern ssize_t pread64(int __fd , void *__buf , size_t __nbytes ,
                       __off64_t __offset ) ;
extern ssize_t pwrite(int __fd , void const   *__buf , size_t __n ,
                      __off_t __offset ) ;
extern ssize_t pread(int __fd , void *__buf , size_t __nbytes ,
                     __off_t __offset ) ;
extern ssize_t write(int __fd , void const   *__buf , size_t __n ) ;
extern ssize_t read(int __fd , void *__buf , size_t __nbytes ) ;
extern int close(int __fd ) ;
extern  __attribute__((__nothrow__)) __off64_t lseek64(int __fd ,
                                                       __off64_t __offset ,
                                                       int __whence ) ;
extern  __attribute__((__nothrow__)) __off_t lseek(int __fd , __off_t __offset ,
                                                   int __whence ) ;
extern  __attribute__((__nothrow__)) int faccessat(int __fd ,
                                                   char const   *__file ,
                                                   int __type , int __flag )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int eaccess(char const   *__name ,
                                                 int __type )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int euidaccess(char const   *__name ,
                                                    int __type )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int access(char const   *__name ,
                                                int __type )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int toupper_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int __toupper_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int tolower_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int __tolower_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int isblank_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isxdigit_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isupper_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isspace_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int ispunct_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isprint_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isgraph_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int islower_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isdigit_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int iscntrl_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isalpha_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isalnum_l(int  , __locale_t  ) ;
typedef int __int32_t;
extern  __attribute__((__nothrow__)) __int32_t const   **__ctype_toupper_loc(void)  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) int toupper(int __c ) ;
__inline extern int toupper(int __c ) 
{ __int32_t const   **tmp ;
  __int32_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1101\n");
  fflush(_coverage_fout);
  }
  if (__c >= -128) {
    {
    fprintf(_coverage_fout, "1099\n");
    fflush(_coverage_fout);
    }
    if (__c < 256) {
      {
      fprintf(_coverage_fout, "1096\n");
      fflush(_coverage_fout);
      }
      tmp = __ctype_toupper_loc();
      {
      fprintf(_coverage_fout, "1097\n");
      fflush(_coverage_fout);
      }
      tmp___0 = *(*tmp + __c);
    } else {
      {
      fprintf(_coverage_fout, "1098\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (int const   )__c;
    }
  } else {
    {
    fprintf(_coverage_fout, "1100\n");
    fflush(_coverage_fout);
    }
    tmp___0 = (int const   )__c;
  }
  {
  fprintf(_coverage_fout, "1102\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) int toupper(int __c ) ;
extern  __attribute__((__nothrow__)) __int32_t const   **__ctype_tolower_loc(void)  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) int tolower(int __c ) ;
__inline extern int tolower(int __c ) 
{ __int32_t const   **tmp ;
  __int32_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1094\n");
  fflush(_coverage_fout);
  }
  if (__c >= -128) {
    {
    fprintf(_coverage_fout, "1092\n");
    fflush(_coverage_fout);
    }
    if (__c < 256) {
      {
      fprintf(_coverage_fout, "1089\n");
      fflush(_coverage_fout);
      }
      tmp = __ctype_tolower_loc();
      {
      fprintf(_coverage_fout, "1090\n");
      fflush(_coverage_fout);
      }
      tmp___0 = *(*tmp + __c);
    } else {
      {
      fprintf(_coverage_fout, "1091\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (int const   )__c;
    }
  } else {
    {
    fprintf(_coverage_fout, "1093\n");
    fflush(_coverage_fout);
    }
    tmp___0 = (int const   )__c;
  }
  {
  fprintf(_coverage_fout, "1095\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) int tolower(int __c ) ;
extern  __attribute__((__nothrow__)) int _tolower(int  ) ;
extern  __attribute__((__nothrow__)) int _toupper(int  ) ;
extern  __attribute__((__nothrow__)) int toascii(int __c ) ;
extern  __attribute__((__nothrow__)) int isascii(int __c ) ;
extern  __attribute__((__nothrow__)) int isctype(int __c , int __mask ) ;
extern  __attribute__((__nothrow__)) int isblank(int  ) ;
extern  __attribute__((__nothrow__)) int isxdigit(int  ) ;
extern  __attribute__((__nothrow__)) int isupper(int  ) ;
extern  __attribute__((__nothrow__)) int isspace(int  ) ;
extern  __attribute__((__nothrow__)) int ispunct(int  ) ;
extern  __attribute__((__nothrow__)) int isprint(int  ) ;
extern  __attribute__((__nothrow__)) int isgraph(int  ) ;
extern  __attribute__((__nothrow__)) int islower(int  ) ;
extern  __attribute__((__nothrow__)) int isdigit(int  ) ;
extern  __attribute__((__nothrow__)) int iscntrl(int  ) ;
extern  __attribute__((__nothrow__)) int isalpha(int  ) ;
extern  __attribute__((__nothrow__)) int isalnum(int  ) ;
extern  __attribute__((__nothrow__)) unsigned short const   **__ctype_b_loc(void)  __attribute__((__const__)) ;
extern size_t __attribute__((__visibility__("default")))  php_strlcat(char *dst ,
                                                                      char const   *src ,
                                                                      size_t siz ) ;
extern size_t __attribute__((__visibility__("default")))  php_strlcpy(char *dst ,
                                                                      char const   *src ,
                                                                      size_t siz ) ;
extern void __attribute__((__visibility__("default")))  zif_display_disabled_class(int ht ,
                                                                                   zval *return_value ,
                                                                                   zval **return_value_ptr ,
                                                                                   zval *this_ptr ,
                                                                                   int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_display_disabled_function(int ht ,
                                                                                      zval *return_value ,
                                                                                      zval **return_value_ptr ,
                                                                                      zval *this_ptr ,
                                                                                      int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zend_rebuild_symbol_table(void) ;
extern void __attribute__((__visibility__("default")))  zend_reset_all_cv(HashTable *symbol_table ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable_ex(char *name ,
                                                                                      int name_len ,
                                                                                      ulong hash_value ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable(char *name ,
                                                                                   int name_len ) ;
extern void __attribute__((__visibility__("default")))  zend_delete_variable(zend_execute_data *ex ,
                                                                             HashTable *ht ,
                                                                             char *name ,
                                                                             int name_len ,
                                                                             ulong hash_value ) ;
extern int __attribute__((__visibility__("default")))  zend_set_hash_symbol(zval *symbol ,
                                                                            char const   *name ,
                                                                            int name_length ,
                                                                            zend_bool is_ref ,
                                                                            int num_symbol_tables 
                                                                            , ...) ;
struct _zend_fcall_info_cache;
typedef struct _zend_fcall_info_cache zend_fcall_info_cache;
struct _zend_fcall_info;
typedef struct _zend_fcall_info zend_fcall_info;
extern int __attribute__((__visibility__("default")))  zend_call_function(zend_fcall_info *fci ,
                                                                          zend_fcall_info_cache *fci_cache ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_call(zend_fcall_info *fci ,
                                                                            zend_fcall_info_cache *fcc ,
                                                                            zval **retval ,
                                                                            zval *args ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argn(zend_fcall_info *fci ,
                                                                            int argc 
                                                                            , ...) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argv(zend_fcall_info *fci ,
                                                                            int argc ,
                                                                            va_list *argv ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argp(zend_fcall_info *fci ,
                                                                            int argc ,
                                                                            zval ***argv ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_args(zend_fcall_info *fci ,
                                                                            zval *args ) ;
extern void __attribute__((__visibility__("default")))  zend_fcall_info_args_restore(zend_fcall_info *fci ,
                                                                                     int param_count ,
                                                                                     zval ***params ) ;
extern void __attribute__((__visibility__("default")))  zend_fcall_info_args_save(zend_fcall_info *fci ,
                                                                                  int *param_count ,
                                                                                  zval ****params ) ;
extern void __attribute__((__visibility__("default")))  zend_fcall_info_args_clear(zend_fcall_info *fci ,
                                                                                   int free_mem ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_init(zval *callable ,
                                                                            uint check_flags ,
                                                                            zend_fcall_info *fci ,
                                                                            zend_fcall_info_cache *fcc ,
                                                                            char **callable_name ,
                                                                            char **error ) ;
extern zend_fcall_info_cache const __attribute__((__visibility__("default")))  empty_fcall_info_cache ;
extern zend_fcall_info const __attribute__((__visibility__("default")))  empty_fcall_info ;
extern int __attribute__((__visibility__("default")))  call_user_function_ex(HashTable *function_table ,
                                                                             zval **object_pp ,
                                                                             zval *function_name ,
                                                                             zval **retval_ptr_ptr ,
                                                                             zend_uint param_count ,
                                                                             zval ***params ,
                                                                             int no_separation ,
                                                                             HashTable *symbol_table ) ;
extern int __attribute__((__visibility__("default")))  call_user_function(HashTable *function_table ,
                                                                          zval **object_pp ,
                                                                          zval *function_name ,
                                                                          zval *retval_ptr ,
                                                                          zend_uint param_count ,
                                                                          zval **params ) ;
extern int __attribute__((__visibility__("default")))  add_property_zval_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ,
                                                                            zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_property_stringl_ex(zval *arg ,
                                                                               char const   *key ,
                                                                               uint key_len ,
                                                                               char const   *str ,
                                                                               uint length ,
                                                                               int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_property_string_ex(zval *arg ,
                                                                              char const   *key ,
                                                                              uint key_len ,
                                                                              char const   *str ,
                                                                              int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_property_double_ex(zval *arg ,
                                                                              char const   *key ,
                                                                              uint key_len ,
                                                                              double d ) ;
extern int __attribute__((__visibility__("default")))  add_property_resource_ex(zval *arg ,
                                                                                char const   *key ,
                                                                                uint key_len ,
                                                                                long r ) ;
extern int __attribute__((__visibility__("default")))  add_property_bool_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ,
                                                                            int b ) ;
extern int __attribute__((__visibility__("default")))  add_property_null_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ) ;
extern int __attribute__((__visibility__("default")))  add_property_long_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ,
                                                                            long l ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_stringl(zval *arg ,
                                                                             ulong idx ,
                                                                             char const   *str ,
                                                                             uint length ,
                                                                             void **dest ,
                                                                             int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_string(zval *arg ,
                                                                            ulong idx ,
                                                                            char const   *str ,
                                                                            void **dest ,
                                                                            int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_double(zval *arg ,
                                                                            ulong idx ,
                                                                            double d ,
                                                                            void **dest ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_long(zval *arg ,
                                                                          ulong idx ,
                                                                          long l ,
                                                                          void **dest ) ;
extern int __attribute__((__visibility__("default")))  add_get_assoc_stringl_ex(zval *arg ,
                                                                                char const   *key ,
                                                                                uint key_len ,
                                                                                char const   *str ,
                                                                                uint length ,
                                                                                void **dest ,
                                                                                int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_get_assoc_string_ex(zval *arg ,
                                                                               char const   *key ,
                                                                               uint key_len ,
                                                                               char const   *str ,
                                                                               void **dest ,
                                                                               int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_zval(zval *arg ,
                                                                           zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_stringl(zval *arg ,
                                                                              char const   *str ,
                                                                              uint length ,
                                                                              int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_string(zval *arg ,
                                                                             char const   *str ,
                                                                             int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_double(zval *arg ,
                                                                             double d ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_resource(zval *arg ,
                                                                               int r ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_bool(zval *arg ,
                                                                           int b ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_null(zval *arg ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_long(zval *arg ,
                                                                           long n ) ;
extern int __attribute__((__visibility__("default")))  add_index_zval(zval *arg ,
                                                                      ulong index ,
                                                                      zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_index_stringl(zval *arg ,
                                                                         ulong idx ,
                                                                         char const   *str ,
                                                                         uint length ,
                                                                         int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_index_string(zval *arg ,
                                                                        ulong idx ,
                                                                        char const   *str ,
                                                                        int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_index_double(zval *arg ,
                                                                        ulong idx ,
                                                                        double d ) ;
extern int __attribute__((__visibility__("default")))  add_index_resource(zval *arg ,
                                                                          ulong idx ,
                                                                          int r ) ;
extern int __attribute__((__visibility__("default")))  add_index_bool(zval *arg ,
                                                                      ulong idx ,
                                                                      int b ) ;
extern int __attribute__((__visibility__("default")))  add_index_null(zval *arg ,
                                                                      ulong idx ) ;
extern int __attribute__((__visibility__("default")))  add_index_long(zval *arg ,
                                                                      ulong idx ,
                                                                      long n ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_zval_ex(zval *arg ,
                                                                         char const   *key ,
                                                                         uint key_len ,
                                                                         zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_stringl_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ,
                                                                            char *str ,
                                                                            uint length ,
                                                                            int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_string_ex(zval *arg ,
                                                                           char const   *key ,
                                                                           uint key_len ,
                                                                           char *str ,
                                                                           int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_double_ex(zval *arg ,
                                                                           char const   *key ,
                                                                           uint key_len ,
                                                                           double d ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_resource_ex(zval *arg ,
                                                                             char const   *key ,
                                                                             uint key_len ,
                                                                             int r ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_bool_ex(zval *arg ,
                                                                         char const   *key ,
                                                                         uint key_len ,
                                                                         int b ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_null_ex(zval *arg ,
                                                                         char const   *key ,
                                                                         uint key_len ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_long_ex(zval *arg ,
                                                                         char const   *key ,
                                                                         uint key_len ,
                                                                         long n ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_function(zval *arg ,
                                                                          char const   *key ,
                                                                          void (*function_ptr)(int ht ,
                                                                                               zval *return_value ,
                                                                                               zval **return_value_ptr ,
                                                                                               zval *this_ptr ,
                                                                                               int return_value_used ) ) ;
extern void __attribute__((__visibility__("default")))  zend_merge_properties(zval *obj ,
                                                                              HashTable *properties ,
                                                                              int destroy_ht ) ;
extern void __attribute__((__visibility__("default")))  object_properties_init(zend_object *object ,
                                                                               zend_class_entry *class_type ) ;
extern int __attribute__((__visibility__("default")))  _object_and_properties_init(zval *arg ,
                                                                                   zend_class_entry *ce ,
                                                                                   HashTable *properties ) ;
extern int __attribute__((__visibility__("default")))  _object_init_ex(zval *arg ,
                                                                       zend_class_entry *ce ) ;
extern int __attribute__((__visibility__("default")))  _object_init(zval *arg ) ;
extern int __attribute__((__visibility__("default")))  _array_init(zval *arg ,
                                                                   uint size ) ;
extern char __attribute__((__visibility__("default")))  *zend_get_type_by_const(int type ) ;
extern int __attribute__((__visibility__("default")))  zend_get_object_classname(zval const   *object ,
                                                                                 char const   **class_name ,
                                                                                 zend_uint *class_name_len ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_static_property(zend_class_entry *scope ,
                                                                                   char *name ,
                                                                                   int name_length ,
                                                                                   zend_bool silent ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_property(zend_class_entry *scope ,
                                                                            zval *object ,
                                                                            char *name ,
                                                                            int name_length ,
                                                                            zend_bool silent ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_stringl(zend_class_entry *scope ,
                                                                                           char *name ,
                                                                                           int name_length ,
                                                                                           char const   *value ,
                                                                                           int value_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_string(zend_class_entry *scope ,
                                                                                          char *name ,
                                                                                          int name_length ,
                                                                                          char const   *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_double(zend_class_entry *scope ,
                                                                                          char *name ,
                                                                                          int name_length ,
                                                                                          double value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_long(zend_class_entry *scope ,
                                                                                        char *name ,
                                                                                        int name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_bool(zend_class_entry *scope ,
                                                                                        char *name ,
                                                                                        int name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_null(zend_class_entry *scope ,
                                                                                        char *name ,
                                                                                        int name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property(zend_class_entry *scope ,
                                                                                   char *name ,
                                                                                   int name_length ,
                                                                                   zval *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_stringl(zend_class_entry *scope ,
                                                                                     zval *object ,
                                                                                     char *name ,
                                                                                     int name_length ,
                                                                                     char const   *value ,
                                                                                     int value_length ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_string(zend_class_entry *scope ,
                                                                                    zval *object ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    char const   *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_double(zend_class_entry *scope ,
                                                                                    zval *object ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    double value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_long(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_bool(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_null(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char *name ,
                                                                                  int name_length ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property(zend_class_entry *scope ,
                                                                             zval *object ,
                                                                             char *name ,
                                                                             int name_length ,
                                                                             zval *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_class_constants(zend_class_entry *class_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_string(zend_class_entry *ce ,
                                                                                          char const   *name ,
                                                                                          size_t name_length ,
                                                                                          char const   *value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_stringl(zend_class_entry *ce ,
                                                                                           char const   *name ,
                                                                                           size_t name_length ,
                                                                                           char const   *value ,
                                                                                           size_t value_length ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_double(zend_class_entry *ce ,
                                                                                          char const   *name ,
                                                                                          size_t name_length ,
                                                                                          double value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_bool(zend_class_entry *ce ,
                                                                                        char const   *name ,
                                                                                        size_t name_length ,
                                                                                        zend_bool value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_long(zend_class_entry *ce ,
                                                                                        char const   *name ,
                                                                                        size_t name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_null(zend_class_entry *ce ,
                                                                                        char const   *name ,
                                                                                        size_t name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant(zend_class_entry *ce ,
                                                                                   char const   *name ,
                                                                                   size_t name_length ,
                                                                                   zval *value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_stringl(zend_class_entry *ce ,
                                                                                     char *name ,
                                                                                     int name_length ,
                                                                                     char const   *value ,
                                                                                     int value_len ,
                                                                                     int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_string(zend_class_entry *ce ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    char const   *value ,
                                                                                    int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_double(zend_class_entry *ce ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    double value ,
                                                                                    int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_long(zend_class_entry *ce ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_bool(zend_class_entry *ce ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_null(zend_class_entry *ce ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_ex(zend_class_entry *ce ,
                                                                                char const   *name ,
                                                                                int name_length ,
                                                                                zval *property ,
                                                                                int access_type ,
                                                                                char *doc_comment ,
                                                                                int doc_comment_len ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property(zend_class_entry *ce ,
                                                                             char *name ,
                                                                             int name_length ,
                                                                             zval *property ,
                                                                             int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_get_module_started(char const   *module_name ) ;
extern char const __attribute__((__visibility__("default")))  *zend_get_module_version(char const   *module_name ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_make_callable(zval *callable ,
                                                                                char **callable_name ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_callable(zval *callable ,
                                                                              uint check_flags ,
                                                                              char **callable_name ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_callable_ex(zval *callable ,
                                                                                 zval *object_ptr ,
                                                                                 uint check_flags ,
                                                                                 char **callable_name ,
                                                                                 int *callable_name_len ,
                                                                                 zend_fcall_info_cache *fcc ,
                                                                                 char **error ) ;
extern void __attribute__((__visibility__("default")))  zend_wrong_param_count(void) ;
extern int __attribute__((__visibility__("default")))  zend_disable_class(char *class_name ,
                                                                          uint class_name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_disable_function(char *function_name ,
                                                                             uint function_name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_register_class_alias_ex(char const   *name ,
                                                                                    int name_len ,
                                                                                    zend_class_entry *ce ) ;
extern void __attribute__((__visibility__("default")))  zend_class_implements(zend_class_entry *class_entry ,
                                                                              int num_interfaces 
                                                                              , ...) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_interface(zend_class_entry *orig_class_entry ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_class_ex(zend_class_entry *class_entry ,
                                                                                                     zend_class_entry *parent_ce ,
                                                                                                     char *parent_name ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_class(zend_class_entry *class_entry ) ;
extern void __attribute__((__visibility__("default")))  zend_check_magic_method_implementation(zend_class_entry const   *ce ,
                                                                                               zend_function const   *fptr ,
                                                                                               int error_type ) ;
extern void __attribute__((__visibility__("default")))  zend_destroy_modules(void) ;
extern void __attribute__((__visibility__("default")))  zend_collect_module_handlers(void) ;
extern int __attribute__((__visibility__("default")))  zend_startup_modules(void) ;
extern int __attribute__((__visibility__("default")))  zend_startup_module_ex(zend_module_entry *module ) ;
extern zend_module_entry __attribute__((__visibility__("default")))  *zend_register_module_ex(zend_module_entry *module ) ;
extern zend_module_entry __attribute__((__visibility__("default")))  *zend_register_internal_module(zend_module_entry *module_entry ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_module(zend_module_entry *module_entry ) ;
extern void __attribute__((__visibility__("default")))  zend_unregister_functions(zend_function_entry const   *functions ,
                                                                                  int count ,
                                                                                  HashTable *function_table ) ;
extern int __attribute__((__visibility__("default")))  zend_register_functions(zend_class_entry *scope ,
                                                                               zend_function_entry const   *functions ,
                                                                               HashTable *function_table ,
                                                                               int type ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_method_parameters_ex(int flags ,
                                                                                       int num_args ,
                                                                                       zval *this_ptr ,
                                                                                       char const   *type_spec 
                                                                                       , ...) ;
extern char __attribute__((__visibility__("default")))  *zend_zval_type_name(zval const   *arg ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_parameters_ex(int flags ,
                                                                                int num_args ,
                                                                                char const   *type_spec 
                                                                                , ...) ;
extern int __attribute__((__visibility__("default")))  zend_copy_parameters_array(int param_count ,
                                                                                  zval *argument_array ) ;
extern int __attribute__((__visibility__("default")))  _zend_get_parameters_array_ex(int param_count ,
                                                                                     zval ***argument_array ) ;
extern int __attribute__((__visibility__("default"),
__deprecated__))  zend_get_parameters_ex(int param_count  , ...) ;
extern int __attribute__((__visibility__("default")))  _zend_get_parameters_array(int ht ,
                                                                                  int param_count ,
                                                                                  zval **argument_array ) ;
extern int __attribute__((__visibility__("default")))  zend_get_parameters(int ht ,
                                                                           int param_count 
                                                                           , ...) ;
extern int zend_next_free_module(void) ;
extern int __attribute__((__visibility__("default")))  zend_do_fcall(zend_execute_data *execute_data ) ;
struct _zend_free_op;
typedef struct _zend_free_op zend_free_op;
union _temp_variable;
typedef union _temp_variable temp_variable;
union _znode_op;
extern zval __attribute__((__visibility__("default")))  **zend_get_zval_ptr_ptr(int op_type ,
                                                                                znode_op const   *node ,
                                                                                temp_variable const   *Ts ,
                                                                                zend_free_op *should_free ,
                                                                                int type ) ;
extern zval __attribute__((__visibility__("default")))  *zend_get_zval_ptr(int op_type ,
                                                                           znode_op const   *node ,
                                                                           temp_variable const   *Ts ,
                                                                           zend_free_op *should_free ,
                                                                           int type ) ;
typedef int (*user_opcode_handler_t)(zend_execute_data *execute_data );
extern user_opcode_handler_t __attribute__((__visibility__("default")))  zend_get_user_opcode_handler(zend_uchar opcode ) ;
extern int __attribute__((__visibility__("default")))  zend_set_user_opcode_handler(zend_uchar opcode ,
                                                                                    int (*handler)(zend_execute_data *execute_data ) ) ;
extern zval __attribute__((__visibility__("default")))  **zend_get_compiled_variable_value(zend_execute_data const   *execute_data_ptr ,
                                                                                           zend_uint var ) ;
extern void zend_verify_abstract_class(zend_class_entry *ce ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_fetch_class_by_name(char const   *class_name ,
                                                                                              uint class_name_len ,
                                                                                              zend_literal const   *key ,
                                                                                              int fetch_type ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_fetch_class(char const   *class_name ,
                                                                                      uint class_name_len ,
                                                                                      int fetch_type ) ;
extern void __attribute__((__visibility__("default")))  zend_timeout(int dummy ) ;
extern void __attribute__((__visibility__("default")))  zend_unset_timeout(void) ;
extern void __attribute__((__visibility__("default")))  zend_set_timeout(long seconds ,
                                                                         int reset_signals ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_executing(void) ;
extern uint __attribute__((__visibility__("default")))  zend_get_executed_lineno(void) ;
extern char __attribute__((__visibility__("default")))  *zend_get_executed_filename(void) ;
extern char __attribute__((__visibility__("default")))  *get_active_function_name(void) ;
extern char __attribute__((__visibility__("default")))  *get_active_class_name(char **space ) ;
extern void execute_new_code(void) ;
struct _zend_ptr_stack;
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_3_pop)(zend_ptr_stack *stack ,
                                                                                void **a ,
                                                                                void **b ,
                                                                                void **c ) ;
__inline static void ( __attribute__((__always_inline__)) zend_arg_types_stack_3_pop)(zend_ptr_stack *stack ,
                                                                                      zend_class_entry **called_scope ,
                                                                                      zval **object ,
                                                                                      zend_function **fbc ) 
{ void *a ;
  void *b ;
  void *c ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1084\n");
  fflush(_coverage_fout);
  }
  zend_ptr_stack_3_pop(stack, & a, & b, & c);
  {
  fprintf(_coverage_fout, "1085\n");
  fflush(_coverage_fout);
  }
  *called_scope = (zend_class_entry *)a;
  {
  fprintf(_coverage_fout, "1086\n");
  fflush(_coverage_fout);
  }
  *object = (zval *)b;
  {
  fprintf(_coverage_fout, "1087\n");
  fflush(_coverage_fout);
  }
  *fbc = (zend_function *)c;
  {
  fprintf(_coverage_fout, "1088\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_arg_types_stack_3_pop)(zend_ptr_stack *stack ,
                                                                                      zend_class_entry **called_scope ,
                                                                                      zval **object ,
                                                                                      zend_function **fbc ) ;
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_pop)(zend_ptr_stack *stack ,
                                                                                void **a ,
                                                                                void **b ) ;
__inline static void ( __attribute__((__always_inline__)) zend_arg_types_stack_2_pop)(zend_ptr_stack *stack ,
                                                                                      zval **object ,
                                                                                      zend_function **fbc ) 
{ void *a ;
  void *b ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1080\n");
  fflush(_coverage_fout);
  }
  zend_ptr_stack_2_pop(stack, & a, & b);
  {
  fprintf(_coverage_fout, "1081\n");
  fflush(_coverage_fout);
  }
  *object = (zval *)a;
  {
  fprintf(_coverage_fout, "1082\n");
  fflush(_coverage_fout);
  }
  *fbc = (zend_function *)b;
  {
  fprintf(_coverage_fout, "1083\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_arg_types_stack_2_pop)(zend_ptr_stack *stack ,
                                                                                      zval **object ,
                                                                                      zend_function **fbc ) ;
struct _zend_function_state {
   zend_function *function ;
   void **arguments ;
};
typedef struct _zend_function_state zend_function_state;
struct _zend_execute_data {
   struct _zend_op *opline ;
   zend_function_state function_state ;
   zend_function *fbc ;
   zend_class_entry *called_scope ;
   zend_op_array *op_array ;
   zval *object ;
   union _temp_variable *Ts ;
   zval ***CVs ;
   HashTable *symbol_table ;
   struct _zend_execute_data *prev_execute_data ;
   zval *old_error_reporting ;
   zend_bool nested ;
   zval **original_return_value ;
   zend_class_entry *current_scope ;
   zend_class_entry *current_called_scope ;
   zval *current_this ;
   zval *current_object ;
};
__inline static zval **( __attribute__((__always_inline__)) zend_vm_stack_get_arg)(int requested_arg ) 
{ void **p ;
  int arg_count ;
  long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1075\n");
  fflush(_coverage_fout);
  }
  p = ((executor_globals.current_execute_data)->prev_execute_data)->function_state.arguments;
  {
  fprintf(_coverage_fout, "1076\n");
  fflush(_coverage_fout);
  }
  arg_count = (int )((unsigned long )*p);
  {
  fprintf(_coverage_fout, "1077\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_expect((long )(requested_arg > arg_count), 0L);
  {
  fprintf(_coverage_fout, "1078\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "1073\n");
    fflush(_coverage_fout);
    }
    return ((zval **)((void *)0));
  } else {
    {
    fprintf(_coverage_fout, "1074\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "1079\n");
  fflush(_coverage_fout);
  }
  return ((((zval **)p - arg_count) + requested_arg) - 1);
}
}
__inline static zval **( __attribute__((__always_inline__)) zend_vm_stack_get_arg)(int requested_arg ) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free_int)(void *ptr ) ;
__inline static void ( __attribute__((__always_inline__)) i_zval_ptr_dtor)(zval *zval_ptr ) ;
struct _zend_vm_stack {
   void **top ;
   void **end ;
   zend_vm_stack prev ;
};
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_clear_multiple)(void) 
{ void **p ;
  int delete_count ;
  zval *q ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1068\n");
  fflush(_coverage_fout);
  }
  p = (executor_globals.argument_stack)->top - 1;
  {
  fprintf(_coverage_fout, "1069\n");
  fflush(_coverage_fout);
  }
  delete_count = (int )((unsigned long )*p);
  {
  fprintf(_coverage_fout, "1070\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "1062\n");
    fflush(_coverage_fout);
    }
    delete_count --;
    {
    fprintf(_coverage_fout, "1063\n");
    fflush(_coverage_fout);
    }
    if (delete_count >= 0) {
      {
      fprintf(_coverage_fout, "1061\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "1064\n");
    fflush(_coverage_fout);
    }
    p --;
    {
    fprintf(_coverage_fout, "1065\n");
    fflush(_coverage_fout);
    }
    q = *((zval **)p);
    {
    fprintf(_coverage_fout, "1066\n");
    fflush(_coverage_fout);
    }
    *p = (void *)0;
    {
    fprintf(_coverage_fout, "1067\n");
    fflush(_coverage_fout);
    }
    i_zval_ptr_dtor(q);
  }
  {
  fprintf(_coverage_fout, "1071\n");
  fflush(_coverage_fout);
  }
  zend_vm_stack_free_int((void *)p);
  {
  fprintf(_coverage_fout, "1072\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_clear_multiple)(void) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_extend)(int count ) ;
__inline static void **( __attribute__((__always_inline__)) zend_vm_stack_push_args)(int count ) 
{ zend_vm_stack p ;
  void *data ;
  zend_vm_stack r ;
  long tmp ;
  int tmp___0 ;
  void **tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  void **tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1055\n");
  fflush(_coverage_fout);
  }
  tmp___2 = __builtin_expect((long )((executor_globals.argument_stack)->top - (void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)) < count),
                             0L);
  {
  fprintf(_coverage_fout, "1056\n");
  fflush(_coverage_fout);
  }
  if (tmp___2) {
    goto _L;
  } else {
    {
    fprintf(_coverage_fout, "1053\n");
    fflush(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((unsigned int )(executor_globals.argument_stack)->top == (unsigned int )(executor_globals.argument_stack)->end),
                               0L);
    {
    fprintf(_coverage_fout, "1054\n");
    fflush(_coverage_fout);
    }
    if (tmp___3) {
      {
      fprintf(_coverage_fout, "1044\n");
      fflush(_coverage_fout);
      }
      _L: /* CIL Label */ 
      p = executor_globals.argument_stack;
      {
      fprintf(_coverage_fout, "1045\n");
      fflush(_coverage_fout);
      }
      zend_vm_stack_extend(count + 1);
      {
      fprintf(_coverage_fout, "1046\n");
      fflush(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += count;
      {
      fprintf(_coverage_fout, "1047\n");
      fflush(_coverage_fout);
      }
      *((executor_globals.argument_stack)->top) = (void *)((unsigned long )count);
      {
      fprintf(_coverage_fout, "1048\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "1036\n");
        fflush(_coverage_fout);
        }
        tmp___0 = count;
        {
        fprintf(_coverage_fout, "1037\n");
        fflush(_coverage_fout);
        }
        count --;
        {
        fprintf(_coverage_fout, "1038\n");
        fflush(_coverage_fout);
        }
        if (tmp___0 > 0) {
          {
          fprintf(_coverage_fout, "1030\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "1039\n");
        fflush(_coverage_fout);
        }
        (p->top) --;
        {
        fprintf(_coverage_fout, "1040\n");
        fflush(_coverage_fout);
        }
        data = *(p->top);
        {
        fprintf(_coverage_fout, "1041\n");
        fflush(_coverage_fout);
        }
        tmp = __builtin_expect((long )((unsigned int )p->top == (unsigned int )((void **)((char *)p + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)))),
                               0L);
        {
        fprintf(_coverage_fout, "1042\n");
        fflush(_coverage_fout);
        }
        if (tmp) {
          {
          fprintf(_coverage_fout, "1031\n");
          fflush(_coverage_fout);
          }
          r = p;
          {
          fprintf(_coverage_fout, "1032\n");
          fflush(_coverage_fout);
          }
          (executor_globals.argument_stack)->prev = p->prev;
          {
          fprintf(_coverage_fout, "1033\n");
          fflush(_coverage_fout);
          }
          p = p->prev;
          {
          fprintf(_coverage_fout, "1034\n");
          fflush(_coverage_fout);
          }
          _efree((void *)r);
        } else {
          {
          fprintf(_coverage_fout, "1035\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "1043\n");
        fflush(_coverage_fout);
        }
        *((void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)) + count) = data;
      }
      {
      fprintf(_coverage_fout, "1049\n");
      fflush(_coverage_fout);
      }
      tmp___1 = (executor_globals.argument_stack)->top;
      {
      fprintf(_coverage_fout, "1050\n");
      fflush(_coverage_fout);
      }
      ((executor_globals.argument_stack)->top) ++;
      {
      fprintf(_coverage_fout, "1051\n");
      fflush(_coverage_fout);
      }
      return (tmp___1);
    } else {
      {
      fprintf(_coverage_fout, "1052\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "1057\n");
  fflush(_coverage_fout);
  }
  *((executor_globals.argument_stack)->top) = (void *)((unsigned long )count);
  {
  fprintf(_coverage_fout, "1058\n");
  fflush(_coverage_fout);
  }
  tmp___4 = (executor_globals.argument_stack)->top;
  {
  fprintf(_coverage_fout, "1059\n");
  fflush(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  fprintf(_coverage_fout, "1060\n");
  fflush(_coverage_fout);
  }
  return (tmp___4);
}
}
__inline static void **( __attribute__((__always_inline__)) zend_vm_stack_push_args)(int count ) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free)(void *ptr ) 
{ zend_vm_stack p ;
  long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1027\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_expect((long )((unsigned int )((void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U))) == (unsigned int )((void **)ptr)),
                         0L);
  {
  fprintf(_coverage_fout, "1028\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "1020\n");
    fflush(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    fprintf(_coverage_fout, "1021\n");
    fflush(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    fprintf(_coverage_fout, "1022\n");
    fflush(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    fprintf(_coverage_fout, "1026\n");
    fflush(_coverage_fout);
    }
    if (4U > sizeof(void *)) {
      {
      fprintf(_coverage_fout, "1023\n");
      fflush(_coverage_fout);
      }
      ptr = (void *)((char *)ptr - (((sizeof(void *) + 4U) - 1U) & 4294967292U));
      {
      fprintf(_coverage_fout, "1024\n");
      fflush(_coverage_fout);
      }
      (executor_globals.argument_stack)->top = *((void ***)ptr);
    } else {
      {
      fprintf(_coverage_fout, "1025\n");
      fflush(_coverage_fout);
      }
      (executor_globals.argument_stack)->top = (void **)ptr;
    }
  }
  {
  fprintf(_coverage_fout, "1029\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free)(void *ptr ) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free_int)(void *ptr ) 
{ zend_vm_stack p ;
  long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1017\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_expect((long )((unsigned int )((void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U))) == (unsigned int )((void **)ptr)),
                         0L);
  {
  fprintf(_coverage_fout, "1018\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "1013\n");
    fflush(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    fprintf(_coverage_fout, "1014\n");
    fflush(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    fprintf(_coverage_fout, "1015\n");
    fflush(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    fprintf(_coverage_fout, "1016\n");
    fflush(_coverage_fout);
    }
    (executor_globals.argument_stack)->top = (void **)ptr;
  }
  {
  fprintf(_coverage_fout, "1019\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void *( __attribute__((__always_inline__)) zend_vm_stack_alloc)(size_t size ) 
{ void *ret ;
  int extra ;
  void **old_top ;
  long tmp ;
  long tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1008\n");
  fflush(_coverage_fout);
  }
  size = (size + (sizeof(void *) - 1U)) / sizeof(void *);
  {
  fprintf(_coverage_fout, "1009\n");
  fflush(_coverage_fout);
  }
  if (4U > sizeof(void *)) {
    {
    fprintf(_coverage_fout, "1000\n");
    fflush(_coverage_fout);
    }
    extra = (int )((4UL - ((unsigned long )(executor_globals.argument_stack)->top & 3UL)) / (unsigned long )sizeof(void *));
    {
    fprintf(_coverage_fout, "1001\n");
    fflush(_coverage_fout);
    }
    tmp = __builtin_expect((long )((unsigned long )((size + (size_t )extra) + (((sizeof(void *) + 4U) - 1U) & 4294967292U) / sizeof(void *)) > (unsigned long )((executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top)),
                           0L);
    {
    fprintf(_coverage_fout, "1002\n");
    fflush(_coverage_fout);
    }
    if (tmp) {
      {
      fprintf(_coverage_fout, "995\n");
      fflush(_coverage_fout);
      }
      zend_vm_stack_extend((int )size);
    } else {
      {
      fprintf(_coverage_fout, "996\n");
      fflush(_coverage_fout);
      }
      old_top = (executor_globals.argument_stack)->top;
      {
      fprintf(_coverage_fout, "997\n");
      fflush(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += extra;
      {
      fprintf(_coverage_fout, "998\n");
      fflush(_coverage_fout);
      }
      *((executor_globals.argument_stack)->top) = (void *)old_top;
      {
      fprintf(_coverage_fout, "999\n");
      fflush(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += (((sizeof(void *) + 4U) - 1U) & 4294967292U) / sizeof(void *);
    }
  } else {
    {
    fprintf(_coverage_fout, "1007\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "1005\n");
      fflush(_coverage_fout);
      }
      tmp___0 = __builtin_expect((long )((int )size > (executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top),
                                 0L);
      {
      fprintf(_coverage_fout, "1006\n");
      fflush(_coverage_fout);
      }
      if (tmp___0) {
        {
        fprintf(_coverage_fout, "1003\n");
        fflush(_coverage_fout);
        }
        zend_vm_stack_extend((int )size);
      } else {
        {
        fprintf(_coverage_fout, "1004\n");
        fflush(_coverage_fout);
        }

      }
      break;
    }
  }
  {
  fprintf(_coverage_fout, "1010\n");
  fflush(_coverage_fout);
  }
  ret = (void *)(executor_globals.argument_stack)->top;
  {
  fprintf(_coverage_fout, "1011\n");
  fflush(_coverage_fout);
  }
  (executor_globals.argument_stack)->top += size;
  {
  fprintf(_coverage_fout, "1012\n");
  fflush(_coverage_fout);
  }
  return (ret);
}
}
__inline static void *( __attribute__((__always_inline__)) zend_vm_stack_alloc)(size_t size ) ;
__inline static void *( __attribute__((__always_inline__)) zend_vm_stack_pop)(void) 
{ void *el ;
  zend_vm_stack p ;
  long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "990\n");
  fflush(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) --;
  {
  fprintf(_coverage_fout, "991\n");
  fflush(_coverage_fout);
  }
  el = *((executor_globals.argument_stack)->top);
  {
  fprintf(_coverage_fout, "992\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_expect((long )((unsigned int )(executor_globals.argument_stack)->top == (unsigned int )((void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)))),
                         0L);
  {
  fprintf(_coverage_fout, "993\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "986\n");
    fflush(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    fprintf(_coverage_fout, "987\n");
    fflush(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    fprintf(_coverage_fout, "988\n");
    fflush(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    fprintf(_coverage_fout, "989\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "994\n");
  fflush(_coverage_fout);
  }
  return (el);
}
}
__inline static void *( __attribute__((__always_inline__)) zend_vm_stack_pop)(void) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push_nocheck)(void *ptr ) 
{ void **tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "982\n");
  fflush(_coverage_fout);
  }
  tmp = (executor_globals.argument_stack)->top;
  {
  fprintf(_coverage_fout, "983\n");
  fflush(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  fprintf(_coverage_fout, "984\n");
  fflush(_coverage_fout);
  }
  *tmp = ptr;
  {
  fprintf(_coverage_fout, "985\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push_nocheck)(void *ptr ) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push)(void *ptr ) 
{ long tmp ;
  void **tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "977\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "975\n");
    fflush(_coverage_fout);
    }
    tmp = __builtin_expect((long )(1 > (executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top),
                           0L);
    {
    fprintf(_coverage_fout, "976\n");
    fflush(_coverage_fout);
    }
    if (tmp) {
      {
      fprintf(_coverage_fout, "973\n");
      fflush(_coverage_fout);
      }
      zend_vm_stack_extend(1);
    } else {
      {
      fprintf(_coverage_fout, "974\n");
      fflush(_coverage_fout);
      }

    }
    break;
  }
  {
  fprintf(_coverage_fout, "978\n");
  fflush(_coverage_fout);
  }
  tmp___0 = (executor_globals.argument_stack)->top;
  {
  fprintf(_coverage_fout, "979\n");
  fflush(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  fprintf(_coverage_fout, "980\n");
  fflush(_coverage_fout);
  }
  *tmp___0 = ptr;
  {
  fprintf(_coverage_fout, "981\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push)(void *ptr ) ;
__inline static void **( __attribute__((__always_inline__)) zend_vm_stack_top)(void) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "972\n");
  fflush(_coverage_fout);
  }
  return ((executor_globals.argument_stack)->top);
}
}
__inline static void **( __attribute__((__always_inline__)) zend_vm_stack_top)(void) ;
__inline static zend_vm_stack ( __attribute__((__always_inline__)) zend_vm_stack_new_page)(int count ) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_extend)(int count ) 
{ zend_vm_stack p ;
  int tmp ;
  zend_vm_stack tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "966\n");
  fflush(_coverage_fout);
  }
  if (count >= 16368) {
    {
    fprintf(_coverage_fout, "964\n");
    fflush(_coverage_fout);
    }
    tmp = count;
  } else {
    {
    fprintf(_coverage_fout, "965\n");
    fflush(_coverage_fout);
    }
    tmp = 16368;
  }
  {
  fprintf(_coverage_fout, "967\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zend_vm_stack_new_page(tmp);
  {
  fprintf(_coverage_fout, "968\n");
  fflush(_coverage_fout);
  }
  p = tmp___0;
  {
  fprintf(_coverage_fout, "969\n");
  fflush(_coverage_fout);
  }
  p->prev = executor_globals.argument_stack;
  {
  fprintf(_coverage_fout, "970\n");
  fflush(_coverage_fout);
  }
  executor_globals.argument_stack = p;
  {
  fprintf(_coverage_fout, "971\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_destroy)(void) 
{ zend_vm_stack stack ;
  zend_vm_stack p ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "961\n");
  fflush(_coverage_fout);
  }
  stack = executor_globals.argument_stack;
  {
  fprintf(_coverage_fout, "962\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "957\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )stack != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "956\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "958\n");
    fflush(_coverage_fout);
    }
    p = stack->prev;
    {
    fprintf(_coverage_fout, "959\n");
    fflush(_coverage_fout);
    }
    _efree((void *)stack);
    {
    fprintf(_coverage_fout, "960\n");
    fflush(_coverage_fout);
    }
    stack = p;
  }
  {
  fprintf(_coverage_fout, "963\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_destroy)(void) ;
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_init)(void) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "954\n");
  fflush(_coverage_fout);
  }
  executor_globals.argument_stack = zend_vm_stack_new_page(16368);
  {
  fprintf(_coverage_fout, "955\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_init)(void) ;
__inline static zend_vm_stack ( __attribute__((__always_inline__)) zend_vm_stack_new_page)(int count ) 
{ zend_vm_stack page ;
  void __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "948\n");
  fflush(_coverage_fout);
  }
  tmp = _emalloc((((sizeof(*page) + 4U) - 1U) & 4294967292U) + sizeof(void *) * (unsigned int )count);
  {
  fprintf(_coverage_fout, "949\n");
  fflush(_coverage_fout);
  }
  page = (struct _zend_vm_stack *)tmp;
  {
  fprintf(_coverage_fout, "950\n");
  fflush(_coverage_fout);
  }
  page->top = (void **)((char *)page + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U));
  {
  fprintf(_coverage_fout, "951\n");
  fflush(_coverage_fout);
  }
  page->end = page->top + count;
  {
  fprintf(_coverage_fout, "952\n");
  fflush(_coverage_fout);
  }
  page->prev = (struct _zend_vm_stack *)((void *)0);
  {
  fprintf(_coverage_fout, "953\n");
  fflush(_coverage_fout);
  }
  return (page);
}
}
extern int __attribute__((__visibility__("default")))  zval_update_constant_ex(zval **pp ,
                                                                               void *arg ,
                                                                               zend_class_entry *scope ) ;
extern int __attribute__((__visibility__("default")))  zval_update_constant_no_inline_change(zval **pp ,
                                                                                             void *arg ) ;
extern int __attribute__((__visibility__("default")))  zval_update_constant_inline_change(zval **pp ,
                                                                                          void *arg ) ;
extern int __attribute__((__visibility__("default")))  zval_update_constant(zval **pp ,
                                                                            void *arg ) ;
extern void __attribute__((__visibility__("default")))  _zval_ptr_dtor(zval **zval_ptr ) ;
struct _zend_object_handlers {
   void (*add_ref)(zval *object ) ;
   void (*del_ref)(zval *object ) ;
   zend_object_value (*clone_obj)(zval *object ) ;
   zval *(*read_property)(zval *object , zval *member , int type ,
                          struct _zend_literal  const  *key ) ;
   void (*write_property)(zval *object , zval *member , zval *value ,
                          struct _zend_literal  const  *key ) ;
   zval *(*read_dimension)(zval *object , zval *offset , int type ) ;
   void (*write_dimension)(zval *object , zval *offset , zval *value ) ;
   zval **(*get_property_ptr_ptr)(zval *object , zval *member ,
                                  struct _zend_literal  const  *key ) ;
   zval *(*get)(zval *object ) ;
   void (*set)(zval **object , zval *value ) ;
   int (*has_property)(zval *object , zval *member , int has_set_exists ,
                       struct _zend_literal  const  *key ) ;
   void (*unset_property)(zval *object , zval *member ,
                          struct _zend_literal  const  *key ) ;
   int (*has_dimension)(zval *object , zval *member , int check_empty ) ;
   void (*unset_dimension)(zval *object , zval *offset ) ;
   HashTable *(*get_properties)(zval *object ) ;
   union _zend_function *(*get_method)(zval **object_ptr , char *method ,
                                       int method_len ,
                                       struct _zend_literal  const  *key ) ;
   int (*call_method)(char *method , int ht , zval *return_value ,
                      zval **return_value_ptr , zval *this_ptr ,
                      int return_value_used ) ;
   union _zend_function *(*get_constructor)(zval *object ) ;
   zend_class_entry *(*get_class_entry)(zval const   *object ) ;
   int (*get_class_name)(zval const   *object , char **class_name ,
                         zend_uint *class_name_len , int parent ) ;
   int (*compare_objects)(zval *object1 , zval *object2 ) ;
   int (*cast_object)(zval *readobj , zval *retval , int type ) ;
   int (*count_elements)(zval *object , long *count ) ;
   HashTable *(*get_debug_info)(zval *object , int *is_temp ) ;
   int (*get_closure)(zval *obj , zend_class_entry **ce_ptr ,
                      union _zend_function **fptr_ptr , zval **zobj_ptr ) ;
};
extern int __attribute__((__visibility__("default")))  zend_hash_num_elements(HashTable const   *ht ) ;
__inline static int ( __attribute__((__always_inline__)) i_zend_is_true)(zval *op ) 
{ int result ;
  int __attribute__((__visibility__("default")))  tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval tmp___1 ;
  int tmp___2 ;
  zval *tmp___3 ;
  zval *tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch ((int )op->type) {
  {
  fprintf(_coverage_fout, "938\n");
  fflush(_coverage_fout);
  }
  case 0: 
  result = 0;
  break;
  {
  fprintf(_coverage_fout, "939\n");
  fflush(_coverage_fout);
  }
  case 1: 
  case 3: 
  case 7: 
  if (op->value.lval) {
    {
    fprintf(_coverage_fout, "909\n");
    fflush(_coverage_fout);
    }
    result = 1;
  } else {
    {
    fprintf(_coverage_fout, "910\n");
    fflush(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  fprintf(_coverage_fout, "940\n");
  fflush(_coverage_fout);
  }
  case 2: 
  if (op->value.dval) {
    {
    fprintf(_coverage_fout, "911\n");
    fflush(_coverage_fout);
    }
    result = 1;
  } else {
    {
    fprintf(_coverage_fout, "912\n");
    fflush(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  fprintf(_coverage_fout, "941\n");
  fflush(_coverage_fout);
  }
  case 6: 
  if (op->value.str.len == 0) {
    {
    fprintf(_coverage_fout, "913\n");
    fflush(_coverage_fout);
    }
    result = 0;
  } else {
    {
    fprintf(_coverage_fout, "918\n");
    fflush(_coverage_fout);
    }
    if (op->value.str.len == 1) {
      {
      fprintf(_coverage_fout, "916\n");
      fflush(_coverage_fout);
      }
      if ((int )*(op->value.str.val + 0) == 48) {
        {
        fprintf(_coverage_fout, "914\n");
        fflush(_coverage_fout);
        }
        result = 0;
      } else {
        {
        fprintf(_coverage_fout, "915\n");
        fflush(_coverage_fout);
        }
        result = 1;
      }
    } else {
      {
      fprintf(_coverage_fout, "917\n");
      fflush(_coverage_fout);
      }
      result = 1;
    }
  }
  break;
  {
  fprintf(_coverage_fout, "942\n");
  fflush(_coverage_fout);
  }
  case 4: 
  tmp___0 = zend_hash_num_elements((HashTable const   *)op->value.ht);
  {
  fprintf(_coverage_fout, "943\n");
  fflush(_coverage_fout);
  }
  if (tmp___0) {
    {
    fprintf(_coverage_fout, "919\n");
    fflush(_coverage_fout);
    }
    result = 1;
  } else {
    {
    fprintf(_coverage_fout, "920\n");
    fflush(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  fprintf(_coverage_fout, "944\n");
  fflush(_coverage_fout);
  }
  case 5: 
  if ((int )op->type == 5) {
    {
    fprintf(_coverage_fout, "936\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )(op->value.obj.handlers)->get_class_entry != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "934\n");
      fflush(_coverage_fout);
      }
      if ((op->value.obj.handlers)->cast_object) {
        {
        fprintf(_coverage_fout, "923\n");
        fflush(_coverage_fout);
        }
        tmp___2 = (*((op->value.obj.handlers)->cast_object))(op, & tmp___1, 3);
        {
        fprintf(_coverage_fout, "924\n");
        fflush(_coverage_fout);
        }
        if (tmp___2 == 0) {
          {
          fprintf(_coverage_fout, "921\n");
          fflush(_coverage_fout);
          }
          result = (int )tmp___1.value.lval;
          break;
        } else {
          {
          fprintf(_coverage_fout, "922\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "933\n");
        fflush(_coverage_fout);
        }
        if ((op->value.obj.handlers)->get) {
          {
          fprintf(_coverage_fout, "929\n");
          fflush(_coverage_fout);
          }
          tmp___4 = (*((op->value.obj.handlers)->get))(op);
          {
          fprintf(_coverage_fout, "930\n");
          fflush(_coverage_fout);
          }
          tmp___3 = tmp___4;
          {
          fprintf(_coverage_fout, "931\n");
          fflush(_coverage_fout);
          }
          if ((int )tmp___3->type != 5) {
            {
            fprintf(_coverage_fout, "925\n");
            fflush(_coverage_fout);
            }
            convert_to_boolean(tmp___3);
            {
            fprintf(_coverage_fout, "926\n");
            fflush(_coverage_fout);
            }
            result = (int )tmp___3->value.lval;
            {
            fprintf(_coverage_fout, "927\n");
            fflush(_coverage_fout);
            }
            _zval_ptr_dtor(& tmp___3);
            break;
          } else {
            {
            fprintf(_coverage_fout, "928\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "932\n");
          fflush(_coverage_fout);
          }

        }
      }
    } else {
      {
      fprintf(_coverage_fout, "935\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "937\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "945\n");
  fflush(_coverage_fout);
  }
  result = 1;
  break;
  {
  fprintf(_coverage_fout, "946\n");
  fflush(_coverage_fout);
  }
  default: 
  result = 0;
  break;
  }
  {
  fprintf(_coverage_fout, "947\n");
  fflush(_coverage_fout);
  }
  return (result);
}
}
__inline static int ( __attribute__((__always_inline__)) i_zend_is_true)(zval *op ) ;
extern void __attribute__((__visibility__("default")))  gc_remove_zval_from_buffer(zval *zv ) ;
__inline static void ( __attribute__((__always_inline__)) gc_zval_check_possible_root)(zval *z ) ;
__inline static zend_bool ( __attribute__((__always_inline__)) zval_unset_isref_p)(zval *pz ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_delref_p)(zval *pz ) ;
__inline static void ( __attribute__((__always_inline__)) i_zval_ptr_dtor)(zval *zval_ptr ) 
{ zend_uint tmp ;
  zend_uint tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "906\n");
  fflush(_coverage_fout);
  }
  tmp___0 = zval_delref_p(zval_ptr);
  {
  fprintf(_coverage_fout, "907\n");
  fflush(_coverage_fout);
  }
  if (tmp___0) {
    {
    fprintf(_coverage_fout, "896\n");
    fflush(_coverage_fout);
    }
    tmp = zval_refcount_p(zval_ptr);
    {
    fprintf(_coverage_fout, "897\n");
    fflush(_coverage_fout);
    }
    if (tmp == 1U) {
      {
      fprintf(_coverage_fout, "894\n");
      fflush(_coverage_fout);
      }
      zval_unset_isref_p(zval_ptr);
    } else {
      {
      fprintf(_coverage_fout, "895\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "898\n");
    fflush(_coverage_fout);
    }
    gc_zval_check_possible_root(zval_ptr);
  } else {
    {
    fprintf(_coverage_fout, "905\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )zval_ptr != (unsigned int )(& executor_globals.uninitialized_zval)) {
      {
      fprintf(_coverage_fout, "901\n");
      fflush(_coverage_fout);
      }
      if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)zval_ptr)->u.buffered & 4294967292UL)) {
        {
        fprintf(_coverage_fout, "899\n");
        fflush(_coverage_fout);
        }
        gc_remove_zval_from_buffer(zval_ptr);
      } else {
        {
        fprintf(_coverage_fout, "900\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "902\n");
      fflush(_coverage_fout);
      }
      _zval_dtor(zval_ptr);
      {
      fprintf(_coverage_fout, "903\n");
      fflush(_coverage_fout);
      }
      _efree((void *)zval_ptr);
    } else {
      {
      fprintf(_coverage_fout, "904\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "908\n");
  fflush(_coverage_fout);
  }
  return;
}
}
extern int __attribute__((__visibility__("default")))  zend_verify_arg_error(int error_type ,
                                                                             zend_function const   *zf ,
                                                                             zend_uint arg_num ,
                                                                             char const   *need_msg ,
                                                                             char const   *need_kind ,
                                                                             char const   *given_msg ,
                                                                             char *given_kind ) ;
extern char __attribute__((__visibility__("default")))  *zend_verify_arg_class_kind(zend_arg_info const   *cur_arg_info ,
                                                                                    ulong fetch_type ,
                                                                                    char const   **class_name ,
                                                                                    zend_class_entry **pce ) ;
extern int __attribute__((__visibility__("default")))  zend_eval_stringl_ex(char *str ,
                                                                            int str_len ,
                                                                            zval *retval_ptr ,
                                                                            char *string_name ,
                                                                            int handle_exceptions ) ;
extern int __attribute__((__visibility__("default")))  zend_eval_string_ex(char *str ,
                                                                           zval *retval_ptr ,
                                                                           char *string_name ,
                                                                           int handle_exceptions ) ;
extern int __attribute__((__visibility__("default")))  zend_eval_stringl(char *str ,
                                                                         int str_len ,
                                                                         zval *retval_ptr ,
                                                                         char *string_name ) ;
extern int __attribute__((__visibility__("default")))  zend_eval_string(char *str ,
                                                                        zval *retval_ptr ,
                                                                        char *string_name ) ;
extern int __attribute__((__visibility__("default")))  zend_lookup_class_ex(char const   *name ,
                                                                            int name_length ,
                                                                            zend_literal const   *key ,
                                                                            int use_autoload ,
                                                                            zend_class_entry ***ce ) ;
__inline static void ( __attribute__((__always_inline__)) safe_free_zval_ptr_rel)(zval *p ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "892\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )p != (unsigned int )executor_globals.uninitialized_zval_ptr) {
    {
    fprintf(_coverage_fout, "890\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "888\n");
      fflush(_coverage_fout);
      }
      if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)p)->u.buffered & 4294967292UL)) {
        {
        fprintf(_coverage_fout, "886\n");
        fflush(_coverage_fout);
        }
        gc_remove_zval_from_buffer(p);
      } else {
        {
        fprintf(_coverage_fout, "887\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "889\n");
      fflush(_coverage_fout);
      }
      _efree((void *)p);
      break;
    }
  } else {
    {
    fprintf(_coverage_fout, "891\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "893\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) safe_free_zval_ptr_rel)(zval *p ) ;
extern int __attribute__((__visibility__("default")))  zend_is_true(zval *op ) ;
extern void __attribute__((__visibility__("default")))  execute_internal(zend_execute_data *execute_data_ptr ,
                                                                         int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  execute(zend_op_array *op_array ) ;
extern void shutdown_destructors(void) ;
extern void shutdown_executor(void) ;
extern void init_executor(void) ;
extern void __attribute__((__visibility__("default")))  (*zend_execute_internal)(zend_execute_data *execute_data_ptr ,
                                                                                 int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  (*zend_execute)(zend_op_array *op_array ) ;
extern int __attribute__((__visibility__("default")))  le_index_ptr ;
extern int __attribute__((__visibility__("default")))  zend_fetch_list_dtor_id(char *type_name ) ;
extern char const __attribute__((__visibility__("default")))  *zend_rsrc_list_get_rsrc_type(int resource ) ;
extern void __attribute__((__visibility__("default")))  *zend_fetch_resource(zval **passed_id ,
                                                                             int default_id ,
                                                                             char const   *resource_type_name ,
                                                                             int *found_resource_type ,
                                                                             int num_resource_types 
                                                                             , ...) ;
extern int __attribute__((__visibility__("default")))  zend_register_resource(zval *rsrc_result ,
                                                                              void *rsrc_pointer ,
                                                                              int rsrc_type ) ;
extern void __attribute__((__visibility__("default")))  *_zend_list_find(int id ,
                                                                         int *type ) ;
extern int __attribute__((__visibility__("default")))  _zend_list_delete(int id ) ;
extern int __attribute__((__visibility__("default")))  _zend_list_addref(int id ) ;
extern int __attribute__((__visibility__("default")))  zend_list_insert(void *ptr ,
                                                                        int type ) ;
extern void zend_destroy_rsrc_list_dtors(void) ;
extern int zend_init_rsrc_list_dtors(void) ;
extern void zend_destroy_rsrc_list(HashTable *ht ) ;
extern int zend_init_rsrc_plist(void) ;
extern int zend_init_rsrc_list(void) ;
extern void zend_clean_module_rsrc_dtors(int module_number ) ;
extern void plist_entry_destructor(void *ptr ) ;
extern void list_entry_destructor(void *ptr ) ;
struct _zend_rsrc_list_entry;
typedef struct _zend_rsrc_list_entry zend_rsrc_list_entry;
extern int __attribute__((__visibility__("default")))  zend_register_list_destructors_ex(void (*ld)(zend_rsrc_list_entry *rsrc ) ,
                                                                                         void (*pld)(zend_rsrc_list_entry *rsrc ) ,
                                                                                         char const   *type_name ,
                                                                                         int module_number ) ;
extern int __attribute__((__visibility__("default")))  zend_register_list_destructors(void (*ld)(void * ) ,
                                                                                      void (*pld)(void * ) ,
                                                                                      int module_number ) ;
extern int module_registry_unload_temp(zend_module_entry const   *module ) ;
extern int module_registry_request_startup(zend_module_entry *module ) ;
extern int module_registry_cleanup(zend_module_entry *module ) ;
extern void module_destructor(zend_module_entry *module ) ;
extern HashTable __attribute__((__visibility__("default")))  module_registry ;
extern int zend_add_literal(zend_op_array *op_array , zval const   *zv ) ;
struct _znode;
typedef struct _znode znode;
extern int zendlex(znode *zendlval ) ;
extern size_t __attribute__((__visibility__("default")))  zend_dirname(char *path ,
                                                                       size_t len ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_auto_global(char const   *name ,
                                                                                 uint name_len ) ;
extern void __attribute__((__visibility__("default")))  zend_activate_auto_globals(void) ;
extern int __attribute__((__visibility__("default")))  zend_register_auto_global(char const   *name ,
                                                                                 uint name_len ,
                                                                                 zend_bool jit ,
                                                                                 zend_bool (*auto_global_callback)(char *name ,
                                                                                                                   uint name_len ) ) ;
extern int zend_get_class_fetch_type(char const   *class_name ,
                                     uint class_name_len ) ;
extern void __attribute__((__visibility__("default")))  zend_initialize_class_data(zend_class_entry *ce ,
                                                                                   zend_bool nullify_handlers ) ;
extern char __attribute__((__visibility__("default")))  *zend_make_compiled_string_description(char const   *name ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_compiling(void) ;
extern void zend_do_mark_last_catch(znode const   *first_catch ,
                                    znode const   *last_additional_catch ) ;
extern void zend_initialize_try_catch_element(znode const   *try_token ) ;
extern void zend_do_first_catch(znode *open_parentheses ) ;
struct _zend_brk_cont_element;
typedef struct _zend_brk_cont_element zend_brk_cont_element;
extern zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array ) ;
extern int __attribute__((__visibility__("default")))  pass_two(zend_op_array *op_array ) ;
extern void print_op_array(zend_op_array *op_array , int optimizations ) ;
extern int print_class(zend_class_entry *class_entry ) ;
extern int get_next_op_number(zend_op_array *op_array ) ;
extern void init_op(zend_op *op ) ;
extern zend_op *get_next_op(zend_op_array *op_array ) ;
extern int __attribute__((__visibility__("default")))  zend_unmangle_property_name(char *mangled_property ,
                                                                                   int mangled_property_len ,
                                                                                   char **class_name ,
                                                                                   char **prop_name ) ;
extern void __attribute__((__visibility__("default")))  zend_mangle_property_name(char **dest ,
                                                                                  int *dest_length ,
                                                                                  char const   *src1 ,
                                                                                  int src1_length ,
                                                                                  char const   *src2 ,
                                                                                  int src2_length ,
                                                                                  int internal ) ;
extern void zend_class_add_ref(zend_class_entry **ce ) ;
extern void __attribute__((__visibility__("default")))  destroy_zend_class(zend_class_entry **pce ) ;
extern void __attribute__((__visibility__("default")))  zend_function_dtor(zend_function *function ) ;
extern void __attribute__((__visibility__("default")))  destroy_zend_function(zend_function *function ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_function_data_full(zend_function *function ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_function_data(zend_function *function ) ;
extern void __attribute__((__visibility__("default")))  zend_cleanup_internal_classes(void) ;
extern void __attribute__((__visibility__("default")))  zend_cleanup_internal_class_data(zend_class_entry *ce ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_user_class_data(zend_class_entry **pce ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_class_data(zend_class_entry **pce ) ;
extern void __attribute__((__visibility__("default")))  zend_destroy_file_handle(zend_file_handle *file_handle ) ;
extern void __attribute__((__visibility__("default")))  destroy_op_array(zend_op_array *op_array ) ;
extern void __attribute__((__visibility__("default")))  init_op_array(zend_op_array *op_array ,
                                                                      zend_uchar type ,
                                                                      int initial_ops_size ) ;
extern int __attribute__((__visibility__("default")))  open_file_for_scanning(zend_file_handle *file_handle ) ;
extern int __attribute__((__visibility__("default")))  zend_execute_scripts(int type ,
                                                                            zval **retval ,
                                                                            int file_count 
                                                                            , ...) ;
extern zend_op_array __attribute__((__visibility__("default")))  *compile_filename(int type ,
                                                                                   zval *filename ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *compile_string(zval *source_string ,
                                                                                 char *filename ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *compile_file(zend_file_handle *file_handle ,
                                                                               int type ) ;
extern void __attribute__((__visibility__("default")))  function_add_ref(zend_function *function ) ;
extern void zend_release_labels(void) ;
extern void zend_resolve_goto_label(zend_op_array *op_array , zend_op *opline ,
                                    int pass2 ) ;
extern void zend_do_goto(znode const   *label ) ;
extern void zend_do_label(znode *label ) ;
extern void zend_do_end_compilation(void) ;
extern void zend_do_use(znode *name , znode *new_name , int is_global ) ;
extern void zend_verify_namespace(void) ;
extern void zend_do_end_namespace(void) ;
extern void zend_do_begin_namespace(znode const   *name ,
                                    zend_bool with_brackets ) ;
extern void zend_do_build_namespace_name(znode *result , znode *prefix ,
                                         znode *name ) ;
extern void zend_do_declare_constant(znode *name , znode *value ) ;
extern void zend_do_abstract_method(znode const   *function_name ,
                                    znode *modifiers , znode const   *body ) ;
extern void zend_do_ticks(void) ;
extern void zend_do_extended_fcall_end(void) ;
extern void zend_do_extended_fcall_begin(void) ;
extern void zend_do_extended_info(void) ;
extern void zend_do_qm_false(znode *result , znode const   *false_value ,
                             znode const   *qm_token ,
                             znode const   *colon_token ) ;
extern void zend_do_qm_true(znode const   *true_value , znode *qm_token ,
                            znode *colon_token ) ;
extern void zend_do_begin_qm_op(znode const   *cond , znode *qm_token ) ;
extern void zend_do_jmp_set_else(znode *result , znode const   *false_value ,
                                 znode const   *jmp_token ,
                                 znode const   *colon_token ) ;
extern void zend_do_jmp_set(znode const   *value , znode *jmp_token ,
                            znode *colon_token ) ;
extern void zend_do_end_silence(znode const   *strudel_token ) ;
extern void zend_do_begin_silence(znode *strudel_token ) ;
extern void zend_do_exit(znode *result , znode const   *message ) ;
extern void zend_do_declare_end(znode const   *declare_token ) ;
extern void zend_do_declare_stmt(znode *var , znode *val ) ;
extern void zend_do_declare_begin(void) ;
extern void zend_do_foreach_end(znode const   *foreach_token ,
                                znode const   *as_token ) ;
extern void zend_do_foreach_cont(znode *foreach_token ,
                                 znode const   *open_brackets_token ,
                                 znode const   *as_token , znode *value ,
                                 znode *key ) ;
extern void zend_do_foreach_begin(znode *foreach_token ,
                                  znode *open_brackets_token , znode *array ,
                                  znode *as_token , int variable ) ;
extern void zend_do_instanceof(znode *result , znode const   *expr ,
                               znode const   *class_znode , int type ) ;
extern void zend_do_isset_or_isempty(int type , znode *result , znode *variable ) ;
extern void zend_do_unset(znode const   *variable ) ;
extern void zend_do_include_or_eval(int type , znode *result ,
                                    znode const   *op1 ) ;
extern void zend_do_cast(znode *result , znode const   *expr , int type ) ;
extern void zend_add_to_list(void *result , void *item ) ;
extern void zend_init_list(void *result , void *item ) ;
extern void zend_do_new_list_end(void) ;
extern void zend_do_new_list_begin(void) ;
extern void zend_do_add_list_element(znode const   *element ) ;
extern void zend_do_list_end(znode *result , znode *expr ) ;
extern void zend_do_list_init(void) ;
extern void zend_do_add_static_array_element(znode *result , znode *offset ,
                                             znode const   *expr ) ;
extern void zend_do_add_array_element(znode *result , znode const   *expr ,
                                      znode const   *offset , zend_bool is_ref ) ;
extern void zend_do_init_array(znode *result , znode const   *expr ,
                               znode const   *offset , zend_bool is_ref ) ;
extern void zend_do_shell_exec(znode *result , znode const   *cmd ) ;
extern void zend_do_fetch_constant(znode *result , znode *constant_container ,
                                   znode *constant_name , int mode ,
                                   zend_bool check_namespace ) ;
extern void zend_do_end_new_object(znode *result , znode const   *new_token ,
                                   znode const   *argument_list ) ;
extern void zend_do_begin_new_object(znode *new_token , znode *class_type ) ;
extern void zend_do_pop_object(znode *object ) ;
extern void zend_do_push_object(znode const   *object ) ;
extern void zend_do_halt_compiler_register(void) ;
extern void zend_do_fetch_property(znode *result , znode *object ,
                                   znode const   *property ) ;
extern void zend_do_declare_class_constant(znode *var_name ,
                                           znode const   *value ) ;
extern void zend_do_declare_property(znode const   *var_name ,
                                     znode const   *value ,
                                     zend_uint access_type ) ;
extern void zend_do_end_class_declaration(znode const   *class_token ,
                                          znode const   *parent_token ) ;
extern void zend_do_begin_class_declaration(znode const   *class_token ,
                                            znode *class_name ,
                                            znode const   *parent_class_name ) ;
extern void zend_do_default_before_statement(znode const   *case_list ,
                                             znode *default_token ) ;
extern void zend_do_case_after_statement(znode *result ,
                                         znode const   *case_token ) ;
extern void zend_do_case_before_statement(znode const   *case_list ,
                                          znode *case_token ,
                                          znode const   *case_expr ) ;
extern void zend_do_switch_end(znode const   *case_list ) ;
extern void zend_do_switch_cond(znode const   *cond ) ;
extern void zend_do_brk_cont(zend_uchar op , znode const   *expr ) ;
extern void zend_do_boolean_and_end(znode *result , znode const   *expr1 ,
                                    znode const   *expr2 ,
                                    znode const   *op_token ) ;
extern void zend_do_boolean_and_begin(znode *expr1 , znode *op_token ) ;
extern void zend_do_boolean_or_end(znode *result , znode const   *expr1 ,
                                   znode const   *expr2 , znode *op_token ) ;
extern void zend_do_boolean_or_begin(znode *expr1 , znode *op_token ) ;
extern void zend_do_pass_param(znode *param , zend_uchar op , int offset ) ;
extern void __attribute__((__visibility__("default")))  zend_do_delayed_early_binding(zend_op_array const   *op_array ) ;
extern void zend_do_early_binding(void) ;
extern void __attribute__((__visibility__("default")))  zend_do_inheritance(zend_class_entry *ce ,
                                                                            zend_class_entry *parent_ce ) ;
extern void init_trait_alias(znode *result , znode const   *method_name ,
                             znode const   *alias , znode const   *modifiers ) ;
extern void add_trait_alias(znode *result , znode const   *trait_alias ) ;
extern void init_trait_alias_list(znode *result , znode const   *trait_alias ) ;
extern void zend_prepare_trait_alias(znode *result , znode *method_reference ,
                                     znode *modifiers , znode *alias ) ;
extern void zend_prepare_reference(znode *result , znode *class_name ,
                                   znode *method_name ) ;
extern void zend_prepare_trait_precedence(znode *result ,
                                          znode *method_reference ,
                                          znode *trait_list ) ;
extern void __attribute__((__visibility__("default")))  zend_do_bind_traits(zend_class_entry *ce ) ;
extern void __attribute__((__visibility__("default")))  zend_do_implement_trait(zend_class_entry *ce ,
                                                                                zend_class_entry *trait ) ;
extern void zend_do_implements_trait(znode *interface_znode ) ;
extern void zend_add_trait_alias(znode *alias_znode ) ;
extern void zend_add_trait_precedence(znode *precedence_znode ) ;
extern void zend_do_implements_interface(znode *interface_znode ) ;
extern void __attribute__((__visibility__("default")))  zend_do_implement_interface(zend_class_entry *ce ,
                                                                                    zend_class_entry *iface ) ;
extern void __attribute__((__visibility__("default")))  zend_do_inherit_interfaces(zend_class_entry *ce ,
                                                                                   zend_class_entry const   *iface ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *do_bind_inherited_class(zend_op_array const   *op_array ,
                                                                                             zend_op const   *opline ,
                                                                                             HashTable *class_table ,
                                                                                             zend_class_entry *parent_ce ,
                                                                                             zend_bool compile_time ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *do_bind_class(zend_op_array const   *op_array ,
                                                                                   zend_op const   *opline ,
                                                                                   HashTable *class_table ,
                                                                                   zend_bool compile_time ) ;
extern int __attribute__((__visibility__("default")))  do_bind_function(zend_op_array const   *op_array ,
                                                                        zend_op *opline ,
                                                                        HashTable *function_table ,
                                                                        zend_bool compile_time ) ;
extern void zend_do_throw(znode const   *expr ) ;
extern void zend_do_end_catch(znode const   *try_token ) ;
extern void zend_do_begin_catch(znode *try_token , znode *catch_class ,
                                znode *catch_var , znode *first_catch ) ;
extern void zend_do_try(znode *try_token ) ;
extern void zend_do_fetch_lexical_variable(znode *varname , zend_bool is_ref ) ;
extern void zend_do_begin_lambda_function_declaration(znode *result ,
                                                      znode *function_token ,
                                                      int return_reference ,
                                                      int is_static ) ;
extern void zend_do_handle_exception(void) ;
extern void zend_do_return(znode *expr , int do_end_vparse ) ;
extern void zend_do_end_function_call(znode *function_name , znode *result ,
                                      znode const   *argument_list ,
                                      int is_method , int is_dynamic_fcall ) ;
extern int zend_do_begin_class_member_function_call(znode *class_name ,
                                                    znode *method_name ) ;
extern void zend_do_build_full_name(znode *result , znode *prefix ,
                                    znode *name , int is_class_member ) ;
extern void zend_do_fetch_class(znode *result , znode *class_name ) ;
extern void zend_do_begin_dynamic_function_call(znode *function_name ,
                                                int prefix_len ) ;
extern void zend_do_clone(znode *result , znode const   *expr ) ;
extern void zend_do_begin_method_call(znode *left_bracket ) ;
extern int zend_do_begin_function_call(znode *function_name ,
                                       zend_bool check_namespace ) ;
extern void zend_do_receive_arg(zend_uchar op , znode *varname ,
                                znode const   *offset ,
                                znode const   *initialization ,
                                znode *class_type , zend_bool pass_by_reference ) ;
extern void zend_do_end_function_declaration(znode const   *function_token ) ;
extern void zend_do_begin_function_declaration(znode *function_token ,
                                               znode *function_name ,
                                               int is_method ,
                                               int return_reference ,
                                               znode *fn_flags_znode ) ;
extern int zend_do_verify_access_types(znode const   *current_access_type ,
                                       znode const   *new_modifier ) ;
extern void zend_do_add_variable(znode *result , znode const   *op1 ,
                                 znode const   *op2 ) ;
extern void zend_do_add_string(znode *result , znode const   *op1 , znode *op2 ) ;
extern void zend_do_free(znode *op1 ) ;
extern void zend_check_writable_variable(znode const   *variable ) ;
extern void zend_do_end_variable_parse(znode *variable , int type ,
                                       int arg_offset ) ;
extern void zend_do_begin_variable_parse(void) ;
extern void zend_do_post_incdec(znode *result , znode const   *op1 ,
                                zend_uchar op ) ;
extern void zend_do_pre_incdec(znode *result , znode const   *op1 ,
                               zend_uchar op ) ;
extern void zend_do_for_end(znode const   *second_semicolon_token ) ;
extern void zend_do_for_before_statement(znode const   *cond_start ,
                                         znode const   *second_semicolon_token ) ;
extern void zend_do_for_cond(znode const   *expr ,
                             znode *second_semicolon_token ) ;
extern void zend_do_if_end(void) ;
extern void zend_do_if_after_statement(znode const   *closing_bracket_token ,
                                       unsigned char initialize ) ;
extern void zend_do_if_cond(znode const   *cond , znode *closing_bracket_token ) ;
extern void zend_do_do_while_end(znode const   *do_token ,
                                 znode const   *expr_open_bracket ,
                                 znode const   *expr ) ;
extern void zend_do_do_while_begin(void) ;
extern void zend_do_while_end(znode const   *while_token ,
                              znode const   *close_bracket_token ) ;
extern void zend_do_while_cond(znode const   *expr , znode *close_bracket_token ) ;
typedef int (*binary_op_type)(zval * , zval * , zval * );
extern binary_op_type __attribute__((__visibility__("default")))  get_binary_op(int opcode ) ;
typedef int (*unary_op_type)(zval * , zval * );
extern unary_op_type __attribute__((__visibility__("default")))  get_unary_op(int opcode ) ;
extern void zend_do_echo(znode const   *arg ) ;
extern void zend_do_print(znode *result , znode const   *arg ) ;
extern void zend_do_fetch_static_member(znode *result , znode *class_znode ) ;
extern void fetch_string_offset(znode *result , znode const   *parent ,
                                znode const   *offset ) ;
extern void fetch_array_dim(znode *result , znode const   *parent ,
                            znode const   *dim ) ;
extern void fetch_array_begin(znode *result , znode *varname , znode *first_dim ) ;
extern void zend_do_fetch_global_variable(znode *varname ,
                                          znode const   *static_assignment ,
                                          int fetch_type ) ;
extern void zend_do_fetch_static_variable(znode *varname ,
                                          znode const   *static_assignment ,
                                          int fetch_type ) ;
extern void zend_do_indirect_references(znode *result ,
                                        znode const   *num_references ,
                                        znode *variable ) ;
extern void fetch_simple_variable_ex(znode *result , znode *varname , int bp ,
                                     zend_uchar op ) ;
extern void fetch_simple_variable(znode *result , znode *varname , int bp ) ;
extern void zend_do_assign_ref(znode *result , znode const   *lvar ,
                               znode const   *rvar ) ;
extern void zend_do_assign(znode *result , znode *variable , znode *value ) ;
extern void zend_do_binary_assign_op(zend_uchar op , znode *result ,
                                     znode const   *op1 , znode const   *op2 ) ;
extern void zend_do_unary_op(zend_uchar op , znode *result , znode const   *op1 ) ;
extern void zend_do_binary_op(zend_uchar op , znode *result ,
                              znode const   *op1 , znode const   *op2 ) ;
extern char __attribute__((__visibility__("default")))  *zend_get_compiled_variable_name(zend_op_array const   *op_array ,
                                                                                         zend_uint var ,
                                                                                         int *name_len ) ;
extern void zend_resolve_class_name(znode *class_name , ulong *fetch_type ,
                                    int check_ns_name ) ;
extern void zend_resolve_non_class_name(znode *element_name ,
                                        zend_bool check_namespace ) ;
extern size_t __attribute__((__visibility__("default")))  zend_get_scanned_file_offset(void) ;
extern int __attribute__((__visibility__("default")))  zend_get_compiled_lineno(void) ;
extern char __attribute__((__visibility__("default")))  *zend_get_compiled_filename(void) ;
extern void __attribute__((__visibility__("default")))  zend_restore_compiled_filename(char *original_compiled_filename ) ;
extern char __attribute__((__visibility__("default")))  *zend_set_compiled_filename(char const   *new_compiled_filename ) ;
extern void shutdown_scanner(void) ;
extern void startup_scanner(void) ;
extern int __attribute__((__visibility__("default")))  lex_scan(zval *zendlval ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *(*zend_compile_string)(zval *source_string ,
                                                                                         char *filename ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *(*zend_compile_file)(zend_file_handle *file_handle ,
                                                                                       int type ) ;
extern void zend_init_compiler_context(void) ;
extern void zend_init_compiler_data_structures(void) ;
extern void shutdown_compiler(void) ;
extern void init_compiler(void) ;
extern size_t __attribute__((__visibility__("default")))  zend_multibyte_internal_encoding_filter(unsigned char **to ,
                                                                                                  size_t *to_length ,
                                                                                                  unsigned char const   *from ,
                                                                                                  size_t from_length ) ;
extern size_t __attribute__((__visibility__("default")))  zend_multibyte_script_encoding_filter(unsigned char **to ,
                                                                                                size_t *to_length ,
                                                                                                unsigned char const   *from ,
                                                                                                size_t from_length ) ;
extern int __attribute__((__visibility__("default")))  zend_multibyte_set_script_encoding_by_string(char const   *new_value ,
                                                                                                    size_t new_value_length ) ;
struct _zend_encoding;
typedef struct _zend_encoding zend_encoding;
extern int __attribute__((__visibility__("default")))  zend_multibyte_set_internal_encoding(zend_encoding const   *encoding ) ;
extern int __attribute__((__visibility__("default")))  zend_multibyte_set_script_encoding(zend_encoding const   **encoding_list ,
                                                                                          size_t encoding_list_size ) ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_get_script_encoding(void) ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_get_internal_encoding(void) ;
extern int __attribute__((__visibility__("default")))  zend_multibyte_parse_encoding_list(char const   *encoding_list ,
                                                                                          size_t encoding_list_len ,
                                                                                          zend_encoding const   ***return_list ,
                                                                                          size_t *return_size ,
                                                                                          int persistent ) ;
extern size_t __attribute__((__visibility__("default")))  zend_multibyte_encoding_converter(unsigned char **to ,
                                                                                            size_t *to_length ,
                                                                                            unsigned char const   *from ,
                                                                                            size_t from_length ,
                                                                                            zend_encoding const   *encoding_to ,
                                                                                            zend_encoding const   *encoding_from ) ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_encoding_detector(unsigned char const   *string ,
                                                                                                         size_t length ,
                                                                                                         zend_encoding const   **list ,
                                                                                                         size_t list_size ) ;
extern int __attribute__((__visibility__("default")))  zend_multibyte_check_lexer_compatibility(zend_encoding const   *encoding ) ;
extern char const __attribute__((__visibility__("default")))  *zend_multibyte_get_encoding_name(zend_encoding const   *encoding ) ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_fetch_encoding(char const   *name ) ;
struct _zend_multibyte_functions;
typedef struct _zend_multibyte_functions zend_multibyte_functions;
extern zend_multibyte_functions const __attribute__((__visibility__("default")))  *zend_multibyte_get_functions(void) ;
extern int __attribute__((__visibility__("default")))  zend_multibyte_set_functions(zend_multibyte_functions const   *functions ) ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_encoding_utf8 ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_encoding_utf16le ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_encoding_utf16be ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_encoding_utf32le ;
extern zend_encoding const __attribute__((__visibility__("default")))  *zend_multibyte_encoding_utf32be ;
extern fpu_control_t __fpu_control ;
extern void __attribute__((__visibility__("default")))  zend_ensure_fpu_mode(void) ;
extern void __attribute__((__visibility__("default")))  zend_shutdown_fpu(void) ;
extern void __attribute__((__visibility__("default")))  zend_init_fpu(void) ;
extern zend_object_handlers __attribute__((__visibility__("default")))  *zend_get_std_object_handlers(void) ;
extern zval __attribute__((__visibility__("default")))  *zend_object_create_proxy(zval *object ,
                                                                                  zval *member ) ;
struct _zend_objects_store;
extern void __attribute__((__visibility__("default")))  zend_objects_store_free_object_storage(zend_objects_store *objects ) ;
extern void __attribute__((__visibility__("default")))  zend_object_store_ctor_failed(zval *zobject ) ;
extern void __attribute__((__visibility__("default")))  zend_object_store_set_object(zval *zobject ,
                                                                                     void *object ) ;
extern void __attribute__((__visibility__("default")))  *zend_object_store_get_object_by_handle(zend_object_handle handle ) ;
extern zend_object_value __attribute__((__visibility__("default")))  zend_objects_store_clone_obj(zval *object ) ;
extern zend_uint __attribute__((__visibility__("default")))  zend_objects_store_get_refcount(zval *object ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_del_ref_by_handle_ex(zend_object_handle handle ,
                                                                                                zend_object_handlers const   *handlers ) ;
__inline static void ( __attribute__((__always_inline__)) zend_objects_store_del_ref_by_handle)(zend_object_handle handle ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "884\n");
  fflush(_coverage_fout);
  }
  zend_objects_store_del_ref_by_handle_ex(handle,
                                          (zend_object_handlers const   *)((void *)0));
  {
  fprintf(_coverage_fout, "885\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_objects_store_del_ref_by_handle)(zend_object_handle handle ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_add_ref_by_handle(zend_object_handle handle ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_del_ref(zval *object ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_add_ref(zval *object ) ;
extern zend_object_handle __attribute__((__visibility__("default")))  zend_objects_store_put(void *object ,
                                                                                             void (*dtor)(void *object ,
                                                                                                          zend_object_handle handle ) ,
                                                                                             void (*storage)(void *object ) ,
                                                                                             void (*clone)(void *object ,
                                                                                                           void **object_clone ) ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_destroy(zend_objects_store *objects ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_mark_destructed(zend_objects_store *objects ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_call_destructors(zend_objects_store *objects ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_init(zend_objects_store *objects ,
                                                                                zend_uint init_size ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_free_object_storage(zend_object *object ) ;
extern zend_object_value __attribute__((__visibility__("default")))  zend_objects_clone_obj(zval *object ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_clone_members(zend_object *new_object ,
                                                                                   zend_object_value new_obj_val ,
                                                                                   zend_object *old_object ,
                                                                                   zend_object_handle handle ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_destroy_object(zend_object *object ,
                                                                                    zend_object_handle handle ) ;
extern zend_object_value __attribute__((__visibility__("default")))  zend_objects_new(zend_object **object ,
                                                                                      zend_class_entry *class_type ) ;
extern void __attribute__((__visibility__("default")))  zend_object_std_dtor(zend_object *object ) ;
extern void __attribute__((__visibility__("default")))  zend_object_std_init(zend_object *object ,
                                                                             zend_class_entry *ce ) ;
__inline static void *( __attribute__((__always_inline__)) zend_ptr_stack_pop)(zend_ptr_stack *stack ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "881\n");
  fflush(_coverage_fout);
  }
  (stack->top) --;
  {
  fprintf(_coverage_fout, "882\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) --;
  {
  fprintf(_coverage_fout, "883\n");
  fflush(_coverage_fout);
  }
  return (*(stack->top_element));
}
}
__inline static void *( __attribute__((__always_inline__)) zend_ptr_stack_pop)(zend_ptr_stack *stack ) ;
extern void __attribute__((__visibility__("default")))  *_erealloc(void *ptr ,
                                                                   size_t size ,
                                                                   int allow_failure ) ;
__inline static void *__zend_realloc(void *p , size_t len ) ;
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_push)(zend_ptr_stack *stack ,
                                                                               void *ptr ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  void **tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "875\n");
  fflush(_coverage_fout);
  }
  if (stack->top + 1 > stack->max) {
    {
    fprintf(_coverage_fout, "870\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "864\n");
      fflush(_coverage_fout);
      }
      stack->max += 64;
      {
      fprintf(_coverage_fout, "865\n");
      fflush(_coverage_fout);
      }
      if (stack->top + 1 > stack->max) {
        {
        fprintf(_coverage_fout, "863\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    fprintf(_coverage_fout, "871\n");
    fflush(_coverage_fout);
    }
    if (stack->persistent) {
      {
      fprintf(_coverage_fout, "866\n");
      fflush(_coverage_fout);
      }
      tmp = __zend_realloc((void *)stack->elements,
                           sizeof(void *) * (unsigned int )stack->max);
      {
      fprintf(_coverage_fout, "867\n");
      fflush(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      fprintf(_coverage_fout, "868\n");
      fflush(_coverage_fout);
      }
      tmp___0 = _erealloc((void *)stack->elements,
                          sizeof(void *) * (unsigned int )stack->max, 0);
      {
      fprintf(_coverage_fout, "869\n");
      fflush(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    fprintf(_coverage_fout, "872\n");
    fflush(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    fprintf(_coverage_fout, "873\n");
    fflush(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    fprintf(_coverage_fout, "874\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "876\n");
  fflush(_coverage_fout);
  }
  (stack->top) ++;
  {
  fprintf(_coverage_fout, "877\n");
  fflush(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  fprintf(_coverage_fout, "878\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  fprintf(_coverage_fout, "879\n");
  fflush(_coverage_fout);
  }
  *tmp___2 = ptr;
  {
  fprintf(_coverage_fout, "880\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_push)(zend_ptr_stack *stack ,
                                                                               void *ptr ) ;
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_pop)(zend_ptr_stack *stack ,
                                                                                void **a ,
                                                                                void **b ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "857\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) --;
  {
  fprintf(_coverage_fout, "858\n");
  fflush(_coverage_fout);
  }
  *a = *(stack->top_element);
  {
  fprintf(_coverage_fout, "859\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) --;
  {
  fprintf(_coverage_fout, "860\n");
  fflush(_coverage_fout);
  }
  *b = *(stack->top_element);
  {
  fprintf(_coverage_fout, "861\n");
  fflush(_coverage_fout);
  }
  stack->top -= 2;
  {
  fprintf(_coverage_fout, "862\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_3_pop)(zend_ptr_stack *stack ,
                                                                                void **a ,
                                                                                void **b ,
                                                                                void **c ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "849\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) --;
  {
  fprintf(_coverage_fout, "850\n");
  fflush(_coverage_fout);
  }
  *a = *(stack->top_element);
  {
  fprintf(_coverage_fout, "851\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) --;
  {
  fprintf(_coverage_fout, "852\n");
  fflush(_coverage_fout);
  }
  *b = *(stack->top_element);
  {
  fprintf(_coverage_fout, "853\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) --;
  {
  fprintf(_coverage_fout, "854\n");
  fflush(_coverage_fout);
  }
  *c = *(stack->top_element);
  {
  fprintf(_coverage_fout, "855\n");
  fflush(_coverage_fout);
  }
  stack->top -= 3;
  {
  fprintf(_coverage_fout, "856\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_push)(zend_ptr_stack *stack ,
                                                                                 void *a ,
                                                                                 void *b ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  void **tmp___2 ;
  void **tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "840\n");
  fflush(_coverage_fout);
  }
  if (stack->top + 2 > stack->max) {
    {
    fprintf(_coverage_fout, "835\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "829\n");
      fflush(_coverage_fout);
      }
      stack->max += 64;
      {
      fprintf(_coverage_fout, "830\n");
      fflush(_coverage_fout);
      }
      if (stack->top + 2 > stack->max) {
        {
        fprintf(_coverage_fout, "828\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    fprintf(_coverage_fout, "836\n");
    fflush(_coverage_fout);
    }
    if (stack->persistent) {
      {
      fprintf(_coverage_fout, "831\n");
      fflush(_coverage_fout);
      }
      tmp = __zend_realloc((void *)stack->elements,
                           sizeof(void *) * (unsigned int )stack->max);
      {
      fprintf(_coverage_fout, "832\n");
      fflush(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      fprintf(_coverage_fout, "833\n");
      fflush(_coverage_fout);
      }
      tmp___0 = _erealloc((void *)stack->elements,
                          sizeof(void *) * (unsigned int )stack->max, 0);
      {
      fprintf(_coverage_fout, "834\n");
      fflush(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    fprintf(_coverage_fout, "837\n");
    fflush(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    fprintf(_coverage_fout, "838\n");
    fflush(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    fprintf(_coverage_fout, "839\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "841\n");
  fflush(_coverage_fout);
  }
  stack->top += 2;
  {
  fprintf(_coverage_fout, "842\n");
  fflush(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  fprintf(_coverage_fout, "843\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  fprintf(_coverage_fout, "844\n");
  fflush(_coverage_fout);
  }
  *tmp___2 = a;
  {
  fprintf(_coverage_fout, "845\n");
  fflush(_coverage_fout);
  }
  tmp___3 = stack->top_element;
  {
  fprintf(_coverage_fout, "846\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  fprintf(_coverage_fout, "847\n");
  fflush(_coverage_fout);
  }
  *tmp___3 = b;
  {
  fprintf(_coverage_fout, "848\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_push)(zend_ptr_stack *stack ,
                                                                                 void *a ,
                                                                                 void *b ) ;
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_3_push)(zend_ptr_stack *stack ,
                                                                                 void *a ,
                                                                                 void *b ,
                                                                                 void *c ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  void **tmp___2 ;
  void **tmp___3 ;
  void **tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "816\n");
  fflush(_coverage_fout);
  }
  if (stack->top + 3 > stack->max) {
    {
    fprintf(_coverage_fout, "811\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "805\n");
      fflush(_coverage_fout);
      }
      stack->max += 64;
      {
      fprintf(_coverage_fout, "806\n");
      fflush(_coverage_fout);
      }
      if (stack->top + 3 > stack->max) {
        {
        fprintf(_coverage_fout, "804\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    fprintf(_coverage_fout, "812\n");
    fflush(_coverage_fout);
    }
    if (stack->persistent) {
      {
      fprintf(_coverage_fout, "807\n");
      fflush(_coverage_fout);
      }
      tmp = __zend_realloc((void *)stack->elements,
                           sizeof(void *) * (unsigned int )stack->max);
      {
      fprintf(_coverage_fout, "808\n");
      fflush(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      fprintf(_coverage_fout, "809\n");
      fflush(_coverage_fout);
      }
      tmp___0 = _erealloc((void *)stack->elements,
                          sizeof(void *) * (unsigned int )stack->max, 0);
      {
      fprintf(_coverage_fout, "810\n");
      fflush(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    fprintf(_coverage_fout, "813\n");
    fflush(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    fprintf(_coverage_fout, "814\n");
    fflush(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    fprintf(_coverage_fout, "815\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "817\n");
  fflush(_coverage_fout);
  }
  stack->top += 3;
  {
  fprintf(_coverage_fout, "818\n");
  fflush(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  fprintf(_coverage_fout, "819\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  fprintf(_coverage_fout, "820\n");
  fflush(_coverage_fout);
  }
  *tmp___2 = a;
  {
  fprintf(_coverage_fout, "821\n");
  fflush(_coverage_fout);
  }
  tmp___3 = stack->top_element;
  {
  fprintf(_coverage_fout, "822\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  fprintf(_coverage_fout, "823\n");
  fflush(_coverage_fout);
  }
  *tmp___3 = b;
  {
  fprintf(_coverage_fout, "824\n");
  fflush(_coverage_fout);
  }
  tmp___4 = stack->top_element;
  {
  fprintf(_coverage_fout, "825\n");
  fflush(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  fprintf(_coverage_fout, "826\n");
  fflush(_coverage_fout);
  }
  *tmp___4 = c;
  {
  fprintf(_coverage_fout, "827\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_3_push)(zend_ptr_stack *stack ,
                                                                                 void *a ,
                                                                                 void *b ,
                                                                                 void *c ) ;
extern int __attribute__((__visibility__("default")))  zend_ptr_stack_num_elements(zend_ptr_stack *stack ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_clean(zend_ptr_stack *stack ,
                                                                             void (*func)(void * ) ,
                                                                             zend_bool free_elements ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_apply(zend_ptr_stack *stack ,
                                                                             void (*func)(void * ) ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_destroy(zend_ptr_stack *stack ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_n_pop(zend_ptr_stack *stack ,
                                                                             int count 
                                                                             , ...) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_n_push(zend_ptr_stack *stack ,
                                                                              int count 
                                                                              , ...) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_init_ex(zend_ptr_stack *stack ,
                                                                               zend_bool persistent ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_init(zend_ptr_stack *stack ) ;
struct _zend_stack;
extern void __attribute__((__visibility__("default")))  zend_stack_apply_with_argument(zend_stack *stack ,
                                                                                       int type ,
                                                                                       int (*apply_function)(void *element ,
                                                                                                             void *arg ) ,
                                                                                       void *arg ) ;
extern void __attribute__((__visibility__("default")))  zend_stack_apply(zend_stack *stack ,
                                                                         int type ,
                                                                         int (*apply_function)(void *element ) ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_count(zend_stack const   *stack ) ;
extern void __attribute__((__visibility__("default")))  **zend_stack_base(zend_stack const   *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_destroy(zend_stack *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_is_empty(zend_stack const   *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_int_top(zend_stack const   *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_del_top(zend_stack *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_top(zend_stack const   *stack ,
                                                                      void **element ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_push(zend_stack *stack ,
                                                                       void const   *element ,
                                                                       int size ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_init(zend_stack *stack ) ;
struct _zend_ini_scanner_globals;
typedef struct _zend_ini_scanner_globals zend_ini_scanner_globals;
extern zend_ini_scanner_globals __attribute__((__visibility__("default")))  ini_scanner_globals ;
struct _zend_php_scanner_globals;
typedef struct _zend_php_scanner_globals zend_php_scanner_globals;
extern zend_php_scanner_globals __attribute__((__visibility__("default")))  language_scanner_globals ;
extern int zendparse(void) ;
struct _zend_compiler_globals;
extern struct _zend_compiler_globals  __attribute__((__visibility__("default"))) compiler_globals ;
struct __jmp_buf_tag;
extern  __attribute__((__nothrow__,
__noreturn__)) void siglongjmp(struct __jmp_buf_tag *__env , int __val ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void _longjmp(struct __jmp_buf_tag *__env , int __val ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void longjmp(struct __jmp_buf_tag *__env , int __val ) ;
extern  __attribute__((__nothrow__)) int _setjmp(struct __jmp_buf_tag *__env ) ;
extern  __attribute__((__nothrow__)) int __sigsetjmp(struct __jmp_buf_tag *__env ,
                                                     int __savemask ) ;
extern  __attribute__((__nothrow__)) int setjmp(struct __jmp_buf_tag *__env ) ;
extern char *zend_visibility_string(zend_uint fn_flags ) ;
typedef int ( __attribute__((__fastcall__)) (*opcode_handler_t))(zend_execute_data *execute_data );
extern opcode_handler_t __attribute__((__visibility__("default")))  *zend_opcode_handlers ;
extern void __attribute__((__visibility__("default")))  zend_qsort(void *base ,
                                                                   size_t nmemb ,
                                                                   size_t siz ,
                                                                   int (*compare)(void const   * ,
                                                                                  void const   * ) ) ;
extern void __attribute__((__visibility__("default")))  zend_save_error_handling(zend_error_handling *current ) ;
extern void __attribute__((__visibility__("default")))  zval_add_ref(zval **p ) ;
extern void __attribute__((__visibility__("default")))  _zval_dtor_wrapper(zval *zvalue ) ;
extern void __attribute__((__visibility__("default")))  _zval_internal_ptr_dtor(zval **zvalue ) ;
extern void __attribute__((__visibility__("default")))  _zval_internal_dtor(zval *zvalue ) ;
extern int __attribute__((__visibility__("default")))  zend_print_variable(zval *var ) ;
struct _zend_hash_key;
typedef struct _zend_hash_key zend_hash_key;
extern int __attribute__((__visibility__("default")))  zval_copy_static_var(zval **p ,
                                                                            int num_args ,
                                                                            va_list args ,
                                                                            zend_hash_key *key ) ;
extern void __attribute__((__visibility__("default")))  _zval_copy_ctor_func(zval *zvalue ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_copy_ctor)(zval *zvalue ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "801\n");
  fflush(_coverage_fout);
  }
  if ((int )zvalue->type <= 3) {
    {
    fprintf(_coverage_fout, "799\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "800\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "802\n");
  fflush(_coverage_fout);
  }
  _zval_copy_ctor_func(zvalue);
  {
  fprintf(_coverage_fout, "803\n");
  fflush(_coverage_fout);
  }
  return;
}
}
extern void __attribute__((__visibility__("default")))  _zval_dtor_func(zval *zvalue ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_dtor)(zval *zvalue ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "796\n");
  fflush(_coverage_fout);
  }
  if ((int )zvalue->type <= 3) {
    {
    fprintf(_coverage_fout, "794\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "795\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "797\n");
  fflush(_coverage_fout);
  }
  _zval_dtor_func(zvalue);
  {
  fprintf(_coverage_fout, "798\n");
  fflush(_coverage_fout);
  }
  return;
}
}
extern void __attribute__((__visibility__("default")))  zend_locale_sprintf_double(zval *op ) ;
extern long __attribute__((__visibility__("default")))  zend_atol(char const   *str ,
                                                                  int str_len ) ;
extern int __attribute__((__visibility__("default")))  zend_atoi(char const   *str ,
                                                                 int str_len ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_objects(zval *result ,
                                                                             zval *o1 ,
                                                                             zval *o2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_arrays(zval *result ,
                                                                            zval *a1 ,
                                                                            zval *a2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_symbol_tables(zval *result ,
                                                                                   HashTable *ht1 ,
                                                                                   HashTable *ht2 ) ;
extern void __attribute__((__visibility__("default")))  zendi_smart_strcmp(zval *result ,
                                                                           zval *s1 ,
                                                                           zval *s2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strncasecmp(char const   *s1 ,
                                                                               uint len1 ,
                                                                               char const   *s2 ,
                                                                               uint len2 ,
                                                                               uint length ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strcasecmp(char const   *s1 ,
                                                                              uint len1 ,
                                                                              char const   *s2 ,
                                                                              uint len2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strncmp(char const   *s1 ,
                                                                           uint len1 ,
                                                                           char const   *s2 ,
                                                                           uint len2 ,
                                                                           uint length ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strcmp(char const   *s1 ,
                                                                          uint len1 ,
                                                                          char const   *s2 ,
                                                                          uint len2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strncasecmp(zval *s1 ,
                                                                                    zval *s2 ,
                                                                                    zval *s3 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strcasecmp(zval *s1 ,
                                                                                   zval *s2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strncmp(zval *s1 ,
                                                                                zval *s2 ,
                                                                                zval *s3 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strcmp(zval *s1 ,
                                                                               zval *s2 ) ;
extern char __attribute__((__visibility__("default")))  *zend_str_tolower_dup(char const   *source ,
                                                                              unsigned int length ) ;
extern char __attribute__((__visibility__("default")))  *zend_str_tolower_copy(char *dest ,
                                                                               char const   *source ,
                                                                               unsigned int length ) ;
extern void __attribute__((__visibility__("default")))  zend_str_tolower(char *str ,
                                                                         unsigned int length ) ;
extern int __attribute__((__visibility__("default")))  string_locale_compare_function(zval *result ,
                                                                                      zval *op1 ,
                                                                                      zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_compare_function(zval *result ,
                                                                               zval *op1 ,
                                                                               zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  numeric_compare_function(zval *result ,
                                                                                zval *op1 ,
                                                                                zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  compare_function(zval *result ,
                                                                        zval *op1 ,
                                                                        zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  zval_is_true(zval *op ) ;
extern double __attribute__((__visibility__("default")))  zend_string_to_double(char const   *number ,
                                                                                zend_uint length ) ;
extern int __attribute__((__visibility__("default")))  add_string_to_string(zval *result ,
                                                                            zval const   *op1 ,
                                                                            zval const   *op2 ) ;
extern int __attribute__((__visibility__("default")))  add_char_to_string(zval *result ,
                                                                          zval const   *op1 ,
                                                                          zval const   *op2 ) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_string_ex(int argc 
                                                                                   , ...) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_double_ex(int argc 
                                                                                   , ...) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_long_ex(int argc 
                                                                                 , ...) ;
extern void __attribute__((__visibility__("default")))  convert_to_object(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_array(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_null(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_long_base(zval *op ,
                                                                             int base ) ;
extern void __attribute__((__visibility__("default")))  convert_to_double(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_scalar_to_number(zval *op ) ;
extern int __attribute__((__visibility__("default")))  decrement_function(zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  increment_function(zval *op1 ) ;
__inline static void const   *zend_memrchr(void const   *s , int c , size_t n ) 
{ register unsigned char const   *e ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "790\n");
  fflush(_coverage_fout);
  }
  if (n <= 0U) {
    {
    fprintf(_coverage_fout, "782\n");
    fflush(_coverage_fout);
    }
    return ((void const   *)((void *)0));
  } else {
    {
    fprintf(_coverage_fout, "783\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "791\n");
  fflush(_coverage_fout);
  }
  e = ((unsigned char const   *)s + n) - 1;
  {
  fprintf(_coverage_fout, "792\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "787\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )e >= (unsigned int )((unsigned char const   *)s)) {
      {
      fprintf(_coverage_fout, "784\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "788\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*e == (int const   )((unsigned char const   )c)) {
      {
      fprintf(_coverage_fout, "785\n");
      fflush(_coverage_fout);
      }
      return ((void const   *)e);
    } else {
      {
      fprintf(_coverage_fout, "786\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "789\n");
    fflush(_coverage_fout);
    }
    e --;
  }
  {
  fprintf(_coverage_fout, "793\n");
  fflush(_coverage_fout);
  }
  return ((void const   *)((void *)0));
}
}
__inline static void const   *zend_memrchr(void const   *s , int c , size_t n ) ;
extern  __attribute__((__nothrow__)) int memcmp(void const   *__s1 ,
                                                void const   *__s2 , size_t __n )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *memchr(void const   *__s , int __c ,
                                                  size_t __n )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline static char *zend_memnstr(char *haystack , char *needle ,
                                   int needle_len , char *end ) 
{ char *p ;
  char ne ;
  void *tmp ;
  int tmp___0 ;
  void *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "775\n");
  fflush(_coverage_fout);
  }
  p = haystack;
  {
  fprintf(_coverage_fout, "776\n");
  fflush(_coverage_fout);
  }
  ne = *(needle + (needle_len - 1));
  {
  fprintf(_coverage_fout, "777\n");
  fflush(_coverage_fout);
  }
  if (needle_len == 1) {
    {
    fprintf(_coverage_fout, "754\n");
    fflush(_coverage_fout);
    }
    tmp = memchr((void const   *)p, (int )*needle, (unsigned int )(end - p));
    {
    fprintf(_coverage_fout, "755\n");
    fflush(_coverage_fout);
    }
    return ((char *)tmp);
  } else {
    {
    fprintf(_coverage_fout, "756\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "778\n");
  fflush(_coverage_fout);
  }
  if (needle_len > end - haystack) {
    {
    fprintf(_coverage_fout, "757\n");
    fflush(_coverage_fout);
    }
    return ((char *)((void *)0));
  } else {
    {
    fprintf(_coverage_fout, "758\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "779\n");
  fflush(_coverage_fout);
  }
  end -= needle_len;
  {
  fprintf(_coverage_fout, "780\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "769\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )p <= (unsigned int )end) {
      {
      fprintf(_coverage_fout, "759\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "770\n");
    fflush(_coverage_fout);
    }
    tmp___1 = memchr((void const   *)p, (int )*needle,
                     (unsigned int )((end - p) + 1));
    {
    fprintf(_coverage_fout, "771\n");
    fflush(_coverage_fout);
    }
    p = (char *)tmp___1;
    {
    fprintf(_coverage_fout, "772\n");
    fflush(_coverage_fout);
    }
    if (p) {
      {
      fprintf(_coverage_fout, "765\n");
      fflush(_coverage_fout);
      }
      if ((int )ne == (int )*(p + (needle_len - 1))) {
        {
        fprintf(_coverage_fout, "762\n");
        fflush(_coverage_fout);
        }
        tmp___0 = memcmp((void const   *)needle, (void const   *)p,
                         (unsigned int )(needle_len - 1));
        {
        fprintf(_coverage_fout, "763\n");
        fflush(_coverage_fout);
        }
        if (tmp___0) {
          {
          fprintf(_coverage_fout, "760\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "761\n");
          fflush(_coverage_fout);
          }
          return (p);
        }
      } else {
        {
        fprintf(_coverage_fout, "764\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      {
      fprintf(_coverage_fout, "766\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "773\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )p == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "767\n");
      fflush(_coverage_fout);
      }
      return ((char *)((void *)0));
    } else {
      {
      fprintf(_coverage_fout, "768\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "774\n");
    fflush(_coverage_fout);
    }
    p ++;
  }
  {
  fprintf(_coverage_fout, "781\n");
  fflush(_coverage_fout);
  }
  return ((char *)((void *)0));
}
}
__inline static char *zend_memnstr(char *haystack , char *needle ,
                                   int needle_len , char *end ) ;
extern  __attribute__((__nothrow__)) long strtol(char const   * __restrict  __nptr ,
                                                 char ** __restrict  __endptr ,
                                                 int __base )  __attribute__((__nonnull__(1))) ;
extern double __attribute__((__visibility__("default")))  zend_strtod(char const   *s00 ,
                                                                      char const   **se ) ;
static char const   long_min_digits[11] ;
extern double __attribute__((__visibility__("default")))  zend_hex_strtod(char const   *str ,
                                                                          char const   **endptr ) ;
__inline static zend_uchar is_numeric_string(char const   *str , int length ,
                                             long *lval , double *dval ,
                                             int allow_errors ) 
{ char const   *ptr ;
  int base ;
  int digits ;
  int dp_or_e ;
  double local_dval ;
  zend_uchar type ;
  char const   *e ;
  char const   *tmp ;
  double __attribute__((__visibility__("default")))  tmp___0 ;
  double __attribute__((__visibility__("default")))  tmp___1 ;
  char const   *tmp___2 ;
  char const   *tmp___3 ;
  int cmp ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___7 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___8 ;
  int tmp___9 ;
  int tmp___10 ;
  double __attribute__((__visibility__("default")))  tmp___11 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "744\n");
  fflush(_coverage_fout);
  }
  base = 10;
  {
  fprintf(_coverage_fout, "745\n");
  fflush(_coverage_fout);
  }
  digits = 0;
  {
  fprintf(_coverage_fout, "746\n");
  fflush(_coverage_fout);
  }
  dp_or_e = 0;
  {
  fprintf(_coverage_fout, "747\n");
  fflush(_coverage_fout);
  }
  if (! length) {
    {
    fprintf(_coverage_fout, "590\n");
    fflush(_coverage_fout);
    }
    return ((unsigned char)0);
  } else {
    {
    fprintf(_coverage_fout, "591\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "748\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "603\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*str == 32) {
      {
      fprintf(_coverage_fout, "592\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "602\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*str == 9) {
        {
        fprintf(_coverage_fout, "593\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "601\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*str == 10) {
          {
          fprintf(_coverage_fout, "594\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "600\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*str == 13) {
            {
            fprintf(_coverage_fout, "595\n");
            fflush(_coverage_fout);
            }

          } else {
            {
            fprintf(_coverage_fout, "599\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*str == 11) {
              {
              fprintf(_coverage_fout, "596\n");
              fflush(_coverage_fout);
              }

            } else {
              {
              fprintf(_coverage_fout, "598\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*str == 12) {
                {
                fprintf(_coverage_fout, "597\n");
                fflush(_coverage_fout);
                }

              } else {
                break;
              }
            }
          }
        }
      }
    }
    {
    fprintf(_coverage_fout, "604\n");
    fflush(_coverage_fout);
    }
    str ++;
    {
    fprintf(_coverage_fout, "605\n");
    fflush(_coverage_fout);
    }
    length --;
  }
  {
  fprintf(_coverage_fout, "749\n");
  fflush(_coverage_fout);
  }
  ptr = str;
  {
  fprintf(_coverage_fout, "750\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*ptr == 45) {
    {
    fprintf(_coverage_fout, "606\n");
    fflush(_coverage_fout);
    }
    ptr ++;
  } else {
    {
    fprintf(_coverage_fout, "609\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*ptr == 43) {
      {
      fprintf(_coverage_fout, "607\n");
      fflush(_coverage_fout);
      }
      ptr ++;
    } else {
      {
      fprintf(_coverage_fout, "608\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "751\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*ptr >= 48) {
    {
    fprintf(_coverage_fout, "678\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*ptr <= 57) {
      {
      fprintf(_coverage_fout, "673\n");
      fflush(_coverage_fout);
      }
      if (length > 2) {
        {
        fprintf(_coverage_fout, "618\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*str == 48) {
          {
          fprintf(_coverage_fout, "616\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*(str + 1) == 120) {
            {
            fprintf(_coverage_fout, "610\n");
            fflush(_coverage_fout);
            }
            base = 16;
            {
            fprintf(_coverage_fout, "611\n");
            fflush(_coverage_fout);
            }
            ptr += 2;
          } else {
            {
            fprintf(_coverage_fout, "615\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*(str + 1) == 88) {
              {
              fprintf(_coverage_fout, "612\n");
              fflush(_coverage_fout);
              }
              base = 16;
              {
              fprintf(_coverage_fout, "613\n");
              fflush(_coverage_fout);
              }
              ptr += 2;
            } else {
              {
              fprintf(_coverage_fout, "614\n");
              fflush(_coverage_fout);
              }

            }
          }
        } else {
          {
          fprintf(_coverage_fout, "617\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "619\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "674\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "621\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*ptr == 48) {
          {
          fprintf(_coverage_fout, "620\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "622\n");
        fflush(_coverage_fout);
        }
        ptr ++;
      }
      {
      fprintf(_coverage_fout, "675\n");
      fflush(_coverage_fout);
      }
      type = (unsigned char)1;
      {
      fprintf(_coverage_fout, "676\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "656\n");
        fflush(_coverage_fout);
        }
        if (digits >= 11) {
          {
          fprintf(_coverage_fout, "625\n");
          fflush(_coverage_fout);
          }
          if (dval) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "624\n");
            fflush(_coverage_fout);
            }
            if (allow_errors == 1) {
              break;
            } else {
              {
              fprintf(_coverage_fout, "623\n");
              fflush(_coverage_fout);
              }

            }
          }
        } else {
          {
          fprintf(_coverage_fout, "626\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "657\n");
        fflush(_coverage_fout);
        }
        check_digits: 
        if ((int const   )*ptr >= 48) {
          {
          fprintf(_coverage_fout, "627\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*ptr <= 57) {
            goto __Cont;
          } else {
            goto _L___3;
          }
        } else {
          {
          fprintf(_coverage_fout, "655\n");
          fflush(_coverage_fout);
          }
          _L___3: /* CIL Label */ 
          if (base == 16) {
            {
            fprintf(_coverage_fout, "631\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*ptr >= 65) {
              {
              fprintf(_coverage_fout, "628\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*ptr <= 70) {
                goto __Cont;
              } else {
                goto _L___2;
              }
            } else {
              {
              fprintf(_coverage_fout, "630\n");
              fflush(_coverage_fout);
              }
              _L___2: /* CIL Label */ 
              if ((int const   )*ptr >= 97) {
                {
                fprintf(_coverage_fout, "629\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*ptr <= 102) {
                  goto __Cont;
                } else {
                  goto _L___1;
                }
              } else {
                goto _L___1;
              }
            }
          } else {
            {
            fprintf(_coverage_fout, "654\n");
            fflush(_coverage_fout);
            }
            _L___1: /* CIL Label */ 
            if (base == 10) {
              {
              fprintf(_coverage_fout, "652\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*ptr == 46) {
                {
                fprintf(_coverage_fout, "632\n");
                fflush(_coverage_fout);
                }
                if (dp_or_e < 1) {
                  goto process_double;
                } else {
                  goto _L___0;
                }
              } else {
                {
                fprintf(_coverage_fout, "651\n");
                fflush(_coverage_fout);
                }
                _L___0: /* CIL Label */ 
                if ((int const   )*ptr == 101) {
                  goto _L;
                } else {
                  {
                  fprintf(_coverage_fout, "650\n");
                  fflush(_coverage_fout);
                  }
                  if ((int const   )*ptr == 69) {
                    {
                    fprintf(_coverage_fout, "648\n");
                    fflush(_coverage_fout);
                    }
                    _L: /* CIL Label */ 
                    if (dp_or_e < 2) {
                      {
                      fprintf(_coverage_fout, "644\n");
                      fflush(_coverage_fout);
                      }
                      e = ptr + 1;
                      {
                      fprintf(_coverage_fout, "645\n");
                      fflush(_coverage_fout);
                      }
                      if ((int const   )*e == 45) {
                        {
                        fprintf(_coverage_fout, "633\n");
                        fflush(_coverage_fout);
                        }
                        tmp = e;
                        {
                        fprintf(_coverage_fout, "634\n");
                        fflush(_coverage_fout);
                        }
                        e ++;
                        {
                        fprintf(_coverage_fout, "635\n");
                        fflush(_coverage_fout);
                        }
                        ptr = tmp;
                      } else {
                        {
                        fprintf(_coverage_fout, "640\n");
                        fflush(_coverage_fout);
                        }
                        if ((int const   )*e == 43) {
                          {
                          fprintf(_coverage_fout, "636\n");
                          fflush(_coverage_fout);
                          }
                          tmp = e;
                          {
                          fprintf(_coverage_fout, "637\n");
                          fflush(_coverage_fout);
                          }
                          e ++;
                          {
                          fprintf(_coverage_fout, "638\n");
                          fflush(_coverage_fout);
                          }
                          ptr = tmp;
                        } else {
                          {
                          fprintf(_coverage_fout, "639\n");
                          fflush(_coverage_fout);
                          }

                        }
                      }
                      {
                      fprintf(_coverage_fout, "646\n");
                      fflush(_coverage_fout);
                      }
                      if ((int const   )*e >= 48) {
                        {
                        fprintf(_coverage_fout, "642\n");
                        fflush(_coverage_fout);
                        }
                        if ((int const   )*e <= 57) {
                          goto process_double;
                        } else {
                          {
                          fprintf(_coverage_fout, "641\n");
                          fflush(_coverage_fout);
                          }

                        }
                      } else {
                        {
                        fprintf(_coverage_fout, "643\n");
                        fflush(_coverage_fout);
                        }

                      }
                    } else {
                      {
                      fprintf(_coverage_fout, "647\n");
                      fflush(_coverage_fout);
                      }

                    }
                  } else {
                    {
                    fprintf(_coverage_fout, "649\n");
                    fflush(_coverage_fout);
                    }

                  }
                }
              }
            } else {
              {
              fprintf(_coverage_fout, "653\n");
              fflush(_coverage_fout);
              }

            }
          }
        }
        break;
        {
        fprintf(_coverage_fout, "658\n");
        fflush(_coverage_fout);
        }
        __Cont: /* CIL Label */ 
        digits ++;
        {
        fprintf(_coverage_fout, "659\n");
        fflush(_coverage_fout);
        }
        ptr ++;
      }
      {
      fprintf(_coverage_fout, "677\n");
      fflush(_coverage_fout);
      }
      if (base == 10) {
        {
        fprintf(_coverage_fout, "662\n");
        fflush(_coverage_fout);
        }
        if (digits >= 11) {
          {
          fprintf(_coverage_fout, "660\n");
          fflush(_coverage_fout);
          }
          dp_or_e = -1;
          goto process_double;
        } else {
          {
          fprintf(_coverage_fout, "661\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "672\n");
        fflush(_coverage_fout);
        }
        if (digits < 8) {
          {
          fprintf(_coverage_fout, "663\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "671\n");
          fflush(_coverage_fout);
          }
          if (digits == 8) {
            {
            fprintf(_coverage_fout, "665\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*(ptr + - digits) <= 55) {
              {
              fprintf(_coverage_fout, "664\n");
              fflush(_coverage_fout);
              }

            } else {
              goto _L___4;
            }
          } else {
            {
            fprintf(_coverage_fout, "669\n");
            fflush(_coverage_fout);
            }
            _L___4: /* CIL Label */ 
            if (dval) {
              {
              fprintf(_coverage_fout, "666\n");
              fflush(_coverage_fout);
              }
              tmp___0 = zend_hex_strtod(str, & ptr);
              {
              fprintf(_coverage_fout, "667\n");
              fflush(_coverage_fout);
              }
              local_dval = (double )tmp___0;
            } else {
              {
              fprintf(_coverage_fout, "668\n");
              fflush(_coverage_fout);
              }

            }
            {
            fprintf(_coverage_fout, "670\n");
            fflush(_coverage_fout);
            }
            type = (unsigned char)2;
          }
        }
      }
    } else {
      goto _L___5;
    }
  } else {
    {
    fprintf(_coverage_fout, "697\n");
    fflush(_coverage_fout);
    }
    _L___5: /* CIL Label */ 
    if ((int const   )*ptr == 46) {
      {
      fprintf(_coverage_fout, "695\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(ptr + 1) >= 48) {
        {
        fprintf(_coverage_fout, "693\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*(ptr + 1) <= 57) {
          {
          fprintf(_coverage_fout, "690\n");
          fflush(_coverage_fout);
          }
          process_double: 
          type = (unsigned char)2;
          {
          fprintf(_coverage_fout, "691\n");
          fflush(_coverage_fout);
          }
          if (dval) {
            {
            fprintf(_coverage_fout, "679\n");
            fflush(_coverage_fout);
            }
            tmp___1 = zend_strtod(str, & ptr);
            {
            fprintf(_coverage_fout, "680\n");
            fflush(_coverage_fout);
            }
            local_dval = (double )tmp___1;
          } else {
            {
            fprintf(_coverage_fout, "689\n");
            fflush(_coverage_fout);
            }
            if (allow_errors != 1) {
              {
              fprintf(_coverage_fout, "687\n");
              fflush(_coverage_fout);
              }
              if (dp_or_e != -1) {
                {
                fprintf(_coverage_fout, "683\n");
                fflush(_coverage_fout);
                }
                tmp___3 = ptr;
                {
                fprintf(_coverage_fout, "684\n");
                fflush(_coverage_fout);
                }
                ptr ++;
                {
                fprintf(_coverage_fout, "685\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*tmp___3 == 46) {
                  {
                  fprintf(_coverage_fout, "681\n");
                  fflush(_coverage_fout);
                  }
                  dp_or_e = 1;
                } else {
                  {
                  fprintf(_coverage_fout, "682\n");
                  fflush(_coverage_fout);
                  }
                  dp_or_e = 2;
                }
                goto check_digits;
              } else {
                {
                fprintf(_coverage_fout, "686\n");
                fflush(_coverage_fout);
                }

              }
            } else {
              {
              fprintf(_coverage_fout, "688\n");
              fflush(_coverage_fout);
              }

            }
          }
        } else {
          {
          fprintf(_coverage_fout, "692\n");
          fflush(_coverage_fout);
          }
          return ((unsigned char)0);
        }
      } else {
        {
        fprintf(_coverage_fout, "694\n");
        fflush(_coverage_fout);
        }
        return ((unsigned char)0);
      }
    } else {
      {
      fprintf(_coverage_fout, "696\n");
      fflush(_coverage_fout);
      }
      return ((unsigned char)0);
    }
  }
  {
  fprintf(_coverage_fout, "752\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )ptr != (unsigned int )(str + length)) {
    {
    fprintf(_coverage_fout, "702\n");
    fflush(_coverage_fout);
    }
    if (! allow_errors) {
      {
      fprintf(_coverage_fout, "698\n");
      fflush(_coverage_fout);
      }
      return ((unsigned char)0);
    } else {
      {
      fprintf(_coverage_fout, "699\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "703\n");
    fflush(_coverage_fout);
    }
    if (allow_errors == -1) {
      {
      fprintf(_coverage_fout, "700\n");
      fflush(_coverage_fout);
      }
      zend_error(1 << 3L, "A non well formed numeric value encountered");
    } else {
      {
      fprintf(_coverage_fout, "701\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "704\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "753\n");
  fflush(_coverage_fout);
  }
  if ((int )type == 1) {
    {
    fprintf(_coverage_fout, "737\n");
    fflush(_coverage_fout);
    }
    if (digits == 10) {
      {
      fprintf(_coverage_fout, "731\n");
      fflush(_coverage_fout);
      }
      if (0) {
        {
        fprintf(_coverage_fout, "716\n");
        fflush(_coverage_fout);
        }
        __s1_len = strlen(ptr + - digits);
        {
        fprintf(_coverage_fout, "717\n");
        fflush(_coverage_fout);
        }
        __s2_len = strlen(long_min_digits);
        {
        fprintf(_coverage_fout, "718\n");
        fflush(_coverage_fout);
        }
        if (! ((unsigned int )((void const   *)((ptr + - digits) + 1)) - (unsigned int )((void const   *)(ptr + - digits)) == 1U)) {
          goto _L___7;
        } else {
          {
          fprintf(_coverage_fout, "711\n");
          fflush(_coverage_fout);
          }
          if (__s1_len >= 4U) {
            {
            fprintf(_coverage_fout, "709\n");
            fflush(_coverage_fout);
            }
            _L___7: /* CIL Label */ 
            if (! ((unsigned int )((void const   *)(long_min_digits + 1)) - (unsigned int )((void const   *)(long_min_digits)) == 1U)) {
              {
              fprintf(_coverage_fout, "705\n");
              fflush(_coverage_fout);
              }
              tmp___10 = 1;
            } else {
              {
              fprintf(_coverage_fout, "708\n");
              fflush(_coverage_fout);
              }
              if (__s2_len >= 4U) {
                {
                fprintf(_coverage_fout, "706\n");
                fflush(_coverage_fout);
                }
                tmp___10 = 1;
              } else {
                {
                fprintf(_coverage_fout, "707\n");
                fflush(_coverage_fout);
                }
                tmp___10 = 0;
              }
            }
          } else {
            {
            fprintf(_coverage_fout, "710\n");
            fflush(_coverage_fout);
            }
            tmp___10 = 0;
          }
        }
        {
        fprintf(_coverage_fout, "719\n");
        fflush(_coverage_fout);
        }
        if (tmp___10) {
          {
          fprintf(_coverage_fout, "712\n");
          fflush(_coverage_fout);
          }
          tmp___5 = __builtin_strcmp(ptr + - digits, long_min_digits);
          {
          fprintf(_coverage_fout, "713\n");
          fflush(_coverage_fout);
          }
          tmp___9 = tmp___5;
        } else {
          {
          fprintf(_coverage_fout, "714\n");
          fflush(_coverage_fout);
          }
          tmp___8 = __builtin_strcmp(ptr + - digits, long_min_digits);
          {
          fprintf(_coverage_fout, "715\n");
          fflush(_coverage_fout);
          }
          tmp___9 = tmp___8;
        }
      } else {
        {
        fprintf(_coverage_fout, "720\n");
        fflush(_coverage_fout);
        }
        tmp___8 = __builtin_strcmp(ptr + - digits, long_min_digits);
        {
        fprintf(_coverage_fout, "721\n");
        fflush(_coverage_fout);
        }
        tmp___9 = tmp___8;
      }
      {
      fprintf(_coverage_fout, "732\n");
      fflush(_coverage_fout);
      }
      cmp = tmp___9;
      {
      fprintf(_coverage_fout, "733\n");
      fflush(_coverage_fout);
      }
      if (cmp < 0) {
        {
        fprintf(_coverage_fout, "722\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "730\n");
        fflush(_coverage_fout);
        }
        if (cmp == 0) {
          {
          fprintf(_coverage_fout, "724\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*str == 45) {
            {
            fprintf(_coverage_fout, "723\n");
            fflush(_coverage_fout);
            }

          } else {
            goto _L___8;
          }
        } else {
          {
          fprintf(_coverage_fout, "728\n");
          fflush(_coverage_fout);
          }
          _L___8: /* CIL Label */ 
          if (dval) {
            {
            fprintf(_coverage_fout, "725\n");
            fflush(_coverage_fout);
            }
            tmp___11 = zend_strtod(str, (char const   **)((void *)0));
            {
            fprintf(_coverage_fout, "726\n");
            fflush(_coverage_fout);
            }
            *dval = (double )tmp___11;
          } else {
            {
            fprintf(_coverage_fout, "727\n");
            fflush(_coverage_fout);
            }

          }
          {
          fprintf(_coverage_fout, "729\n");
          fflush(_coverage_fout);
          }
          return ((unsigned char)2);
        }
      }
    } else {
      {
      fprintf(_coverage_fout, "734\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "738\n");
    fflush(_coverage_fout);
    }
    if (lval) {
      {
      fprintf(_coverage_fout, "735\n");
      fflush(_coverage_fout);
      }
      *lval = strtol((char const   */* __restrict  */)str,
                     (char **/* __restrict  */)((void *)0), base);
    } else {
      {
      fprintf(_coverage_fout, "736\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "739\n");
    fflush(_coverage_fout);
    }
    return ((unsigned char)1);
  } else {
    {
    fprintf(_coverage_fout, "742\n");
    fflush(_coverage_fout);
    }
    if (dval) {
      {
      fprintf(_coverage_fout, "740\n");
      fflush(_coverage_fout);
      }
      *dval = local_dval;
    } else {
      {
      fprintf(_coverage_fout, "741\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "743\n");
    fflush(_coverage_fout);
    }
    return ((unsigned char)2);
  }
}
}
__inline static zend_uchar is_numeric_string(char const   *str , int length ,
                                             long *lval , double *dval ,
                                             int allow_errors ) ;
__inline static long ( __attribute__((__always_inline__)) zend_dval_to_lval)(double d ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "588\n");
  fflush(_coverage_fout);
  }
  if (d > (double )2147483647L) {
    {
    fprintf(_coverage_fout, "584\n");
    fflush(_coverage_fout);
    }
    return ((long )((unsigned long )((long long )d)));
  } else {
    {
    fprintf(_coverage_fout, "587\n");
    fflush(_coverage_fout);
    }
    if (d < (double )(-0x7FFFFFFF-1)) {
      {
      fprintf(_coverage_fout, "585\n");
      fflush(_coverage_fout);
      }
      return ((long )((unsigned long )((long long )d)));
    } else {
      {
      fprintf(_coverage_fout, "586\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "589\n");
  fflush(_coverage_fout);
  }
  return ((long )d);
}
}
__inline static long ( __attribute__((__always_inline__)) zend_dval_to_lval)(double d ) ;
extern zend_bool __attribute__((__visibility__("default")))  instanceof_function_ex(zend_class_entry const   *instance_ce ,
                                                                                    zend_class_entry const   *ce ,
                                                                                    zend_bool interfaces_only ) ;
extern int __attribute__((__visibility__("default")))  is_smaller_or_equal_function(zval *result ,
                                                                                    zval *op1 ,
                                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_smaller_function(zval *result ,
                                                                           zval *op1 ,
                                                                           zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_not_equal_function(zval *result ,
                                                                             zval *op1 ,
                                                                             zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_not_identical_function(zval *result ,
                                                                                 zval *op1 ,
                                                                                 zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_identical_function(zval *result ,
                                                                             zval *op1 ,
                                                                             zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_equal_function(zval *result ,
                                                                         zval *op1 ,
                                                                         zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  concat_function(zval *result ,
                                                                       zval *op1 ,
                                                                       zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  shift_right_function(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  shift_left_function(zval *result ,
                                                                           zval *op1 ,
                                                                           zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_xor_function(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_and_function(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_or_function(zval *result ,
                                                                           zval *op1 ,
                                                                           zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_not_function(zval *result ,
                                                                            zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  boolean_not_function(zval *result ,
                                                                            zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  boolean_xor_function(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  mod_function(zval *result ,
                                                                    zval *op1 ,
                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  div_function(zval *result ,
                                                                    zval *op1 ,
                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  mul_function(zval *result ,
                                                                    zval *op1 ,
                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  sub_function(zval *result ,
                                                                    zval *op1 ,
                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  add_function(zval *result ,
                                                                    zval *op1 ,
                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  zend_shutdown_strtod(void) ;
extern int __attribute__((__visibility__("default")))  zend_startup_strtod(void) ;
extern double __attribute__((__visibility__("default")))  zend_oct_strtod(char const   *str ,
                                                                          char const   **endptr ) ;
extern char __attribute__((__visibility__("default")))  *zend_dtoa(double _d ,
                                                                   int mode ,
                                                                   int ndigits ,
                                                                   int *decpt ,
                                                                   int *sign ,
                                                                   char **rve ) ;
extern void __attribute__((__visibility__("default")))  zend_freedtoa(char *s ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void __assert(char const   *__assertion , char const   *__file ,
                             int __line ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void __assert_perror_fail(int __errnum , char const   *__file ,
                                         unsigned int __line ,
                                         char const   *__function ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void __assert_fail(char const   *__assertion ,
                                  char const   *__file , unsigned int __line ,
                                  char const   *__function ) ;
extern char *program_invocation_short_name ;
extern char *program_invocation_name ;
extern  __attribute__((__nothrow__)) int *__errno_location(void)  __attribute__((__const__)) ;
struct _zend_gc_globals;
typedef struct _zend_gc_globals zend_gc_globals;
extern zend_gc_globals __attribute__((__visibility__("default")))  gc_globals ;
union __anonunion_u_45 {
   zval *pz ;
   zend_object_handlers *handlers ;
};
struct _gc_root_buffer {
   struct _gc_root_buffer *prev ;
   struct _gc_root_buffer *next ;
   zend_object_handle handle ;
   union __anonunion_u_45 u ;
};
struct _zend_gc_globals {
   zend_bool gc_enabled ;
   zend_bool gc_active ;
   gc_root_buffer *buf ;
   gc_root_buffer roots ;
   gc_root_buffer *unused ;
   gc_root_buffer *first_unused ;
   gc_root_buffer *last_unused ;
   zval_gc_info *zval_to_free ;
   zval_gc_info *free_list ;
   zval_gc_info *next_to_free ;
   zend_uint gc_runs ;
   zend_uint collected ;
};
__inline static void ( __attribute__((__always_inline__)) gc_remove_from_buffer)(gc_root_buffer *root ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "579\n");
  fflush(_coverage_fout);
  }
  (root->next)->prev = root->prev;
  {
  fprintf(_coverage_fout, "580\n");
  fflush(_coverage_fout);
  }
  (root->prev)->next = root->next;
  {
  fprintf(_coverage_fout, "581\n");
  fflush(_coverage_fout);
  }
  root->prev = gc_globals.unused;
  {
  fprintf(_coverage_fout, "582\n");
  fflush(_coverage_fout);
  }
  gc_globals.unused = root;
  {
  fprintf(_coverage_fout, "583\n");
  fflush(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) gc_remove_from_buffer)(gc_root_buffer *root ) ;
extern void __attribute__((__visibility__("default")))  gc_zval_possible_root(zval *zv ) ;
__inline static void ( __attribute__((__always_inline__)) gc_zval_check_possible_root)(zval *z ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "577\n");
  fflush(_coverage_fout);
  }
  if ((int )z->type == 4) {
    {
    fprintf(_coverage_fout, "573\n");
    fflush(_coverage_fout);
    }
    gc_zval_possible_root(z);
  } else {
    {
    fprintf(_coverage_fout, "576\n");
    fflush(_coverage_fout);
    }
    if ((int )z->type == 5) {
      {
      fprintf(_coverage_fout, "574\n");
      fflush(_coverage_fout);
      }
      gc_zval_possible_root(z);
    } else {
      {
      fprintf(_coverage_fout, "575\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "578\n");
  fflush(_coverage_fout);
  }
  return;
}
}
extern void __attribute__((__visibility__("default")))  gc_reset(void) ;
extern void __attribute__((__visibility__("default")))  gc_init(void) ;
extern void __attribute__((__visibility__("default")))  gc_globals_dtor(void) ;
extern void __attribute__((__visibility__("default")))  gc_globals_ctor(void) ;
extern void __attribute__((__visibility__("default")))  gc_zobj_possible_root(zval *zv ) ;
extern int __attribute__((__visibility__("default")))  gc_collect_cycles(void) ;
extern int __attribute__((__visibility__("default")))  zend_get_configuration_directive(char const   *name ,
                                                                                        uint name_length ,
                                                                                        zval *contents ) ;
extern void __attribute__((__visibility__("default")))  zend_message_dispatcher(long message ,
                                                                                void *data ) ;
extern zval __attribute__((__visibility__("default")))  zval_used_for_init ;
struct _zend_utility_values;
typedef struct _zend_utility_values zend_utility_values;
extern zend_utility_values __attribute__((__visibility__("default")))  zend_uv ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_standard_class_def ;
extern void zenderror(char const   *error ) ;
extern char __attribute__((__visibility__("default")))  *(*zend_resolve_path)(char const   *filename ,
                                                                              int filename_len ) ;
extern char __attribute__((__visibility__("default")))  *(*zend_getenv)(char *name ,
                                                                        size_t name_len ) ;
extern int (*zend_vspprintf)(char **pbuf , size_t max_len ,
                             char const   *format , va_list ap ) ;
extern int __attribute__((__visibility__("default")))  (*zend_stream_open_function)(char const   *filename ,
                                                                                    zend_file_handle *handle ) ;
extern void (*zend_on_timeout)(int seconds ) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  (*zend_error_cb))(int type ,
                                                                                                    char const   *error_filename ,
                                                                                                    uint error_lineno ,
                                                                                                    char const   *format ,
                                                                                                    va_list args ) ;
extern void __attribute__((__visibility__("default")))  (*zend_ticks_function)(int ticks ) ;
extern void __attribute__((__visibility__("default")))  (*zend_unblock_interruptions)(void) ;
extern void __attribute__((__visibility__("default")))  (*zend_block_interruptions)(void) ;
extern FILE __attribute__((__visibility__("default")))  *(*zend_fopen)(char const   *filename ,
                                                                       char **opened_path ) ;
extern int (* __attribute__((__visibility__("default"))) zend_write)(char const   *str ,
                                                                     uint str_length ) ;
extern int __attribute__((__visibility__("default")))  ( /* format attribute */  (*zend_printf))(char const   *format 
                                                                                                 , ...) ;
extern void __attribute__((__visibility__("default")))  free_estring(char **str_p ) ;
extern void zend_post_deactivate_modules(void) ;
extern void zend_deactivate_modules(void) ;
extern void zend_activate_modules(void) ;
extern void zend_call_destructors(void) ;
extern void zend_deactivate(void) ;
extern void zend_activate(void) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  zend_output_debug_string)(zend_bool trigger_break ,
                                                                                                            char const   *format 
                                                                                                            , ...) ;
extern void __attribute__((__visibility__("default")))  zend_print_zval_r_ex(int (*write_func)(char const   *str ,
                                                                                               uint str_length ) ,
                                                                             zval *expr ,
                                                                             int indent ) ;
extern void __attribute__((__visibility__("default")))  zend_print_flat_zval_r(zval *expr ) ;
extern void __attribute__((__visibility__("default")))  zend_print_zval_r(zval *expr ,
                                                                          int indent ) ;
extern int __attribute__((__visibility__("default")))  zend_print_zval_ex(int (*write_func)(char const   *str ,
                                                                                            uint str_length ) ,
                                                                          zval *expr ,
                                                                          int indent ) ;
extern int __attribute__((__visibility__("default")))  zend_print_zval(zval *expr ,
                                                                       int indent ) ;
extern void __attribute__((__visibility__("default")))  zend_make_printable_zval(zval *expr ,
                                                                                 zval *expr_copy ,
                                                                                 int *use_copy ) ;
extern char __attribute__((__visibility__("default")))  *get_zend_version(void) ;
extern void __attribute__((__visibility__("default")))  _zend_bailout(char *filename ,
                                                                      uint lineno ) ;
extern void zend_set_utility_values(zend_utility_values *utility_values ) ;
extern void zend_post_startup(void) ;
extern void zend_register_standard_ini_entries(void) ;
extern void zend_shutdown(void) ;
struct _zend_utility_functions;
typedef struct _zend_utility_functions zend_utility_functions;
extern int zend_startup(zend_utility_functions *utility_functions ,
                        char **extensions ) ;
extern int __attribute__((__visibility__("default")))  zend_compare_file_handles(zend_file_handle *fh1 ,
                                                                                 zend_file_handle *fh2 ) ;
extern void __attribute__((__visibility__("default")))  zend_file_handle_dtor(zend_file_handle *fh ) ;
extern int __attribute__((__visibility__("default")))  zend_stream_fixup(zend_file_handle *file_handle ,
                                                                         char **buf ,
                                                                         size_t *len ) ;
extern int __attribute__((__visibility__("default")))  zend_stream_open(char const   *filename ,
                                                                        zend_file_handle *handle ) ;
extern void __attribute__((__visibility__("default")))  zend_register_iterator_wrapper(void) ;
extern zval __attribute__((__visibility__("default")))  *zend_iterator_wrap(zend_object_iterator *iter ) ;
enum zend_object_iterator_kind;
extern enum zend_object_iterator_kind  __attribute__((__visibility__("default"))) zend_iterator_unwrap(zval *array_ptr ,
                                                                                                       zend_object_iterator **iter ) ;
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_to_p)(zval *pz ,
                                                                                    zend_bool isref ) 
{ zend_uchar tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "570\n");
  fflush(_coverage_fout);
  }
  tmp = isref;
  {
  fprintf(_coverage_fout, "571\n");
  fflush(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  fprintf(_coverage_fout, "572\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_to_p)(zval *pz ,
                                                                                    zend_bool isref ) ;
__inline static zend_bool ( __attribute__((__always_inline__)) zval_unset_isref_p)(zval *pz ) 
{ zend_uchar tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "567\n");
  fflush(_coverage_fout);
  }
  tmp = (unsigned char)0;
  {
  fprintf(_coverage_fout, "568\n");
  fflush(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  fprintf(_coverage_fout, "569\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_p)(zval *pz ) 
{ zend_uchar tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "564\n");
  fflush(_coverage_fout);
  }
  tmp = (unsigned char)1;
  {
  fprintf(_coverage_fout, "565\n");
  fflush(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  fprintf(_coverage_fout, "566\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_p)(zval *pz ) ;
__inline static zend_bool ( __attribute__((__always_inline__)) zval_isref_p)(zval *pz ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "563\n");
  fflush(_coverage_fout);
  }
  return (pz->is_ref__gc);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_isref_p)(zval *pz ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_delref_p)(zval *pz ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "561\n");
  fflush(_coverage_fout);
  }
  (pz->refcount__gc) --;
  {
  fprintf(_coverage_fout, "562\n");
  fflush(_coverage_fout);
  }
  return (pz->refcount__gc);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_addref_p)(zval *pz ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "559\n");
  fflush(_coverage_fout);
  }
  (pz->refcount__gc) ++;
  {
  fprintf(_coverage_fout, "560\n");
  fflush(_coverage_fout);
  }
  return (pz->refcount__gc);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_addref_p)(zval *pz ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_set_refcount_p)(zval *pz ,
                                                                                    zend_uint rc ) 
{ zend_uint tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "556\n");
  fflush(_coverage_fout);
  }
  tmp = rc;
  {
  fprintf(_coverage_fout, "557\n");
  fflush(_coverage_fout);
  }
  pz->refcount__gc = tmp;
  {
  fprintf(_coverage_fout, "558\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_set_refcount_p)(zval *pz ,
                                                                                    zend_uint rc ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_refcount_p)(zval *pz ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "555\n");
  fflush(_coverage_fout);
  }
  return (pz->refcount__gc);
}
}
extern void __attribute__((__visibility__("default")))  zend_std_call_user_call(int ht ,
                                                                                zval *return_value ,
                                                                                zval **return_value_ptr ,
                                                                                zval *this_ptr ,
                                                                                int return_value_used ) ;
extern int __attribute__((__visibility__("default")))  zend_check_property_access(zend_object *zobj ,
                                                                                  char *prop_info_name ,
                                                                                  int prop_info_name_len ) ;
extern int __attribute__((__visibility__("default")))  zend_check_protected(zend_class_entry *ce ,
                                                                            zend_class_entry *scope ) ;
extern int __attribute__((__visibility__("default")))  zend_check_private(union _zend_function *fbc ,
                                                                          zend_class_entry *ce ,
                                                                          char *function_name_strval ,
                                                                          int function_name_strlen ) ;
extern void __attribute__((__visibility__("default")))  rebuild_object_properties(zend_object *zobj ) ;
extern void __attribute__((__visibility__("default")))  zend_std_write_property(zval *object ,
                                                                                zval *member ,
                                                                                zval *value ,
                                                                                struct _zend_literal  const  *key ) ;
extern int __attribute__((__visibility__("default")))  zend_std_cast_object_tostring(zval *readobj ,
                                                                                     zval *writeobj ,
                                                                                     int type ) ;
extern HashTable __attribute__((__visibility__("default")))  *zend_std_get_debug_info(zval *object ,
                                                                                      int *is_temp ) ;
extern HashTable __attribute__((__visibility__("default")))  *zend_std_get_properties(zval *object ) ;
struct _zend_property_info;
extern struct _zend_property_info  __attribute__((__visibility__("default"))) *zend_get_property_info(zend_class_entry *ce ,
                                                                                                      zval *member ,
                                                                                                      int silent ) ;
extern union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_constructor(zval *object ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_std_unset_static_property(zend_class_entry *ce ,
                                                                                            char *property_name ,
                                                                                            int property_name_len ,
                                                                                            struct _zend_literal  const  *key ) ;
extern zval __attribute__((__visibility__("default")))  **zend_std_get_static_property(zend_class_entry *ce ,
                                                                                       char *property_name ,
                                                                                       int property_name_len ,
                                                                                       zend_bool silent ,
                                                                                       struct _zend_literal  const  *key ) ;
extern union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_static_method(zend_class_entry *ce ,
                                                                                                    char *function_name_strval ,
                                                                                                    int function_name_strlen ,
                                                                                                    struct _zend_literal  const  *key ) ;
extern zend_object_handlers __attribute__((__visibility__("default")))  std_object_handlers ;
extern  __attribute__((__noreturn__)) void zend_error_noreturn(int type ,
                                                               char const   *format 
                                                               , ...) ;
struct _zend_llist_element;
typedef struct _zend_llist_element zend_llist_element;
typedef zend_llist_element *zend_llist_position;
struct _zend_llist;
typedef struct _zend_llist zend_llist;
extern void __attribute__((__visibility__("default")))  *zend_llist_get_prev_ex(zend_llist *l ,
                                                                                zend_llist_position *pos ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_get_next_ex(zend_llist *l ,
                                                                                zend_llist_position *pos ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_get_last_ex(zend_llist *l ,
                                                                                zend_llist_position *pos ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_get_first_ex(zend_llist *l ,
                                                                                 zend_llist_position *pos ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_sort(zend_llist *l ,
                                                                        int (*comp_func)(zend_llist_element const   ** ,
                                                                                         zend_llist_element const   ** ) ) ;
extern int __attribute__((__visibility__("default")))  zend_llist_count(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_apply_with_arguments(zend_llist *l ,
                                                                                        void (*func)(void *data ,
                                                                                                     int num_args ,
                                                                                                     va_list args ) ,
                                                                                        int num_args 
                                                                                        , ...) ;
extern void __attribute__((__visibility__("default")))  zend_llist_apply_with_argument(zend_llist *l ,
                                                                                       void (*func)(void *data ,
                                                                                                    void *arg ) ,
                                                                                       void *arg ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_apply_with_del(zend_llist *l ,
                                                                                  int (*func)(void *data ) ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_apply(zend_llist *l ,
                                                                         void (*func)(void * ) ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_copy(zend_llist *dst ,
                                                                        zend_llist *src ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_remove_tail(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_clean(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_destroy(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_del_element(zend_llist *l ,
                                                                               void *element ,
                                                                               int (*compare)(void *element1 ,
                                                                                              void *element2 ) ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_prepend_element(zend_llist *l ,
                                                                                   void *element ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_add_element(zend_llist *l ,
                                                                               void *element ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_init(zend_llist *l ,
                                                                        size_t size ,
                                                                        void (*dtor)(void * ) ,
                                                                        unsigned char persistent ) ;
extern ulong __attribute__((__visibility__("default")))  zend_ts_hash_func(char *arKey ,
                                                                           uint nKeyLength ) ;
struct _zend_ts_hashtable;
typedef struct _zend_ts_hashtable TsHashTable;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_rehash(TsHashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_num_elements(TsHashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_minmax(TsHashTable *ht ,
                                                                           int (*compar)(void const   * ,
                                                                                         void const   * ) ,
                                                                           int flag ,
                                                                           void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_compare(TsHashTable *ht1 ,
                                                                            TsHashTable *ht2 ,
                                                                            int (*compar)(void const   * ,
                                                                                          void const   * ) ,
                                                                            zend_bool ordered ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_sort(TsHashTable *ht ,
                                                                         void (*sort_func)(void * ,
                                                                                           size_t  ,
                                                                                           size_t  ,
                                                                                           int (*)(void const   * ,
                                                                                                   void const   * ) ) ,
                                                                         int (*compare_func)(void const   * ,
                                                                                             void const   * ) ,
                                                                         int renumber ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_merge_ex(TsHashTable *target ,
                                                                              TsHashTable *source ,
                                                                              void (*pCopyConstructor)(void *pElement ) ,
                                                                              uint size ,
                                                                              zend_bool (*pMergeSource)(HashTable *target_ht ,
                                                                                                        void *source_data ,
                                                                                                        zend_hash_key *hash_key ,
                                                                                                        void *pParam ) ,
                                                                              void *pParam ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_merge(TsHashTable *target ,
                                                                           TsHashTable *source ,
                                                                           void (*pCopyConstructor)(void *pElement ) ,
                                                                           void *tmp ,
                                                                           uint size ,
                                                                           int overwrite ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_copy_to_hash(HashTable *target ,
                                                                                  TsHashTable *source ,
                                                                                  void (*pCopyConstructor)(void *pElement ) ,
                                                                                  void *tmp ,
                                                                                  uint size ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_copy(TsHashTable *target ,
                                                                          TsHashTable *source ,
                                                                          void (*pCopyConstructor)(void *pElement ) ,
                                                                          void *tmp ,
                                                                          uint size ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_index_exists(TsHashTable *ht ,
                                                                                 ulong h ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_exists(TsHashTable *ht ,
                                                                           char *arKey ,
                                                                           uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_index_find(TsHashTable *ht ,
                                                                               ulong h ,
                                                                               void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_quick_find(TsHashTable *ht ,
                                                                               char *arKey ,
                                                                               uint nKeyLength ,
                                                                               ulong h ,
                                                                               void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_find(TsHashTable *ht ,
                                                                         char *arKey ,
                                                                         uint nKeyLength ,
                                                                         void **pData ) ;
extern ulong __attribute__((__visibility__("default")))  zend_ts_get_hash_value(TsHashTable *ht ,
                                                                                char *arKey ,
                                                                                uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_del_key_or_index(TsHashTable *ht ,
                                                                                     char *arKey ,
                                                                                     uint nKeyLength ,
                                                                                     ulong h ,
                                                                                     int flag ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_reverse_apply(TsHashTable *ht ,
                                                                                   int (*apply_func)(void *pDest ) ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_apply_with_arguments(TsHashTable *ht ,
                                                                                          int (*apply_func)(void *pDest ,
                                                                                                            int num_args ,
                                                                                                            va_list args ,
                                                                                                            zend_hash_key *hash_key ) ,
                                                                                          int  
                                                                                          , ...) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_apply_with_argument(TsHashTable *ht ,
                                                                                         int (*apply_func)(void *pDest ,
                                                                                                           void *argument ) ,
                                                                                         void * ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_apply(TsHashTable *ht ,
                                                                           int (*apply_func)(void *pDest ) ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_graceful_destroy(TsHashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_add_empty_element(TsHashTable *ht ,
                                                                                      char *arKey ,
                                                                                      uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  _zend_ts_hash_index_update_or_next_insert(TsHashTable *ht ,
                                                                                                 ulong h ,
                                                                                                 void *pData ,
                                                                                                 uint nDataSize ,
                                                                                                 void **pDest ,
                                                                                                 int flag ) ;
extern int __attribute__((__visibility__("default")))  _zend_ts_hash_quick_add_or_update(TsHashTable *ht ,
                                                                                         char *arKey ,
                                                                                         uint nKeyLength ,
                                                                                         ulong h ,
                                                                                         void *pData ,
                                                                                         uint nDataSize ,
                                                                                         void **pDest ,
                                                                                         int flag ) ;
extern int __attribute__((__visibility__("default")))  _zend_ts_hash_add_or_update(TsHashTable *ht ,
                                                                                   char *arKey ,
                                                                                   uint nKeyLength ,
                                                                                   void *pData ,
                                                                                   uint nDataSize ,
                                                                                   void **pDest ,
                                                                                   int flag ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_clean(TsHashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_destroy(TsHashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  _zend_ts_hash_init_ex(TsHashTable *ht ,
                                                                             uint nSize ,
                                                                             ulong (*pHashFunction)(char const   *arKey ,
                                                                                                    uint nKeyLength ) ,
                                                                             void (*pDestructor)(void *pDest ) ,
                                                                             zend_bool persistent ,
                                                                             zend_bool bApplyProtection ) ;
extern int __attribute__((__visibility__("default")))  _zend_ts_hash_init(TsHashTable *ht ,
                                                                          uint nSize ,
                                                                          ulong (*pHashFunction)(char const   *arKey ,
                                                                                                 uint nKeyLength ) ,
                                                                          void (*pDestructor)(void *pDest ) ,
                                                                          zend_bool persistent ) ;
typedef Bucket *HashPosition;
extern int __attribute__((__visibility__("default")))  zend_hash_update_current_key_ex(HashTable *ht ,
                                                                                       int key_type ,
                                                                                       char const   *str_index ,
                                                                                       uint str_length ,
                                                                                       ulong num_index ,
                                                                                       int mode ,
                                                                                       HashPosition *pos ) ;
__inline static int zend_symtable_update_current_key_ex(HashTable *ht ,
                                                        char const   *arKey ,
                                                        uint nKeyLength ,
                                                        int mode ,
                                                        HashPosition *pos ) 
{ ulong idx ;
  register char const   *tmp ;
  char const   *end ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "552\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "551\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "548\n");
      fflush(_coverage_fout);
      }
      tmp = arKey;
      {
      fprintf(_coverage_fout, "549\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        fprintf(_coverage_fout, "516\n");
        fflush(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        fprintf(_coverage_fout, "517\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "550\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        fprintf(_coverage_fout, "546\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          fprintf(_coverage_fout, "540\n");
          fflush(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          fprintf(_coverage_fout, "541\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "524\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              fprintf(_coverage_fout, "518\n");
              fflush(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              fprintf(_coverage_fout, "523\n");
              fflush(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "522\n");
                fflush(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  fprintf(_coverage_fout, "520\n");
                  fflush(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    fprintf(_coverage_fout, "519\n");
                    fflush(_coverage_fout);
                    }

                  }
                } else {
                  {
                  fprintf(_coverage_fout, "521\n");
                  fflush(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          fprintf(_coverage_fout, "542\n");
          fflush(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          fprintf(_coverage_fout, "543\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "528\n");
            fflush(_coverage_fout);
            }
            tmp ++;
            {
            fprintf(_coverage_fout, "529\n");
            fflush(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              fprintf(_coverage_fout, "527\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                fprintf(_coverage_fout, "526\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  fprintf(_coverage_fout, "525\n");
                  fflush(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "530\n");
            fflush(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          fprintf(_coverage_fout, "544\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            fprintf(_coverage_fout, "536\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              fprintf(_coverage_fout, "532\n");
              fflush(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "531\n");
                fflush(_coverage_fout);
                }

              }
              {
              fprintf(_coverage_fout, "533\n");
              fflush(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              fprintf(_coverage_fout, "535\n");
              fflush(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "534\n");
                fflush(_coverage_fout);
                }

              }
            }
            {
            fprintf(_coverage_fout, "537\n");
            fflush(_coverage_fout);
            }
            tmp___0 = zend_hash_update_current_key_ex(ht, 2,
                                                      (char const   *)((void *)0),
                                                      0U, idx, mode, pos);
            {
            fprintf(_coverage_fout, "538\n");
            fflush(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            fprintf(_coverage_fout, "539\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "545\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "547\n");
        fflush(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  fprintf(_coverage_fout, "553\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_hash_update_current_key_ex(ht, 1, arKey, nKeyLength, 0UL, mode,
                                            pos);
  {
  fprintf(_coverage_fout, "554\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__inline static int zend_symtable_update_current_key_ex(HashTable *ht ,
                                                        char const   *arKey ,
                                                        uint nKeyLength ,
                                                        int mode ,
                                                        HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_exists(HashTable const   *ht ,
                                                                        char const   *arKey ,
                                                                        uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_index_exists(HashTable const   *ht ,
                                                                              ulong h ) ;
__inline static int zend_symtable_exists(HashTable *ht , char const   *arKey ,
                                         uint nKeyLength ) 
{ ulong idx ;
  register char const   *tmp ;
  char const   *end ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "513\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "512\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "509\n");
      fflush(_coverage_fout);
      }
      tmp = arKey;
      {
      fprintf(_coverage_fout, "510\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        fprintf(_coverage_fout, "477\n");
        fflush(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        fprintf(_coverage_fout, "478\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "511\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        fprintf(_coverage_fout, "507\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          fprintf(_coverage_fout, "501\n");
          fflush(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          fprintf(_coverage_fout, "502\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "485\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              fprintf(_coverage_fout, "479\n");
              fflush(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              fprintf(_coverage_fout, "484\n");
              fflush(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "483\n");
                fflush(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  fprintf(_coverage_fout, "481\n");
                  fflush(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    fprintf(_coverage_fout, "480\n");
                    fflush(_coverage_fout);
                    }

                  }
                } else {
                  {
                  fprintf(_coverage_fout, "482\n");
                  fflush(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          fprintf(_coverage_fout, "503\n");
          fflush(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          fprintf(_coverage_fout, "504\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "489\n");
            fflush(_coverage_fout);
            }
            tmp ++;
            {
            fprintf(_coverage_fout, "490\n");
            fflush(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              fprintf(_coverage_fout, "488\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                fprintf(_coverage_fout, "487\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  fprintf(_coverage_fout, "486\n");
                  fflush(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "491\n");
            fflush(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          fprintf(_coverage_fout, "505\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            fprintf(_coverage_fout, "497\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              fprintf(_coverage_fout, "493\n");
              fflush(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "492\n");
                fflush(_coverage_fout);
                }

              }
              {
              fprintf(_coverage_fout, "494\n");
              fflush(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              fprintf(_coverage_fout, "496\n");
              fflush(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "495\n");
                fflush(_coverage_fout);
                }

              }
            }
            {
            fprintf(_coverage_fout, "498\n");
            fflush(_coverage_fout);
            }
            tmp___0 = zend_hash_index_exists((HashTable const   *)ht, idx);
            {
            fprintf(_coverage_fout, "499\n");
            fflush(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            fprintf(_coverage_fout, "500\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "506\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "508\n");
        fflush(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  fprintf(_coverage_fout, "514\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_hash_exists((HashTable const   *)ht, arKey, nKeyLength);
  {
  fprintf(_coverage_fout, "515\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__inline static int zend_symtable_exists(HashTable *ht , char const   *arKey ,
                                         uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_find(HashTable const   *ht ,
                                                                      char const   *arKey ,
                                                                      uint nKeyLength ,
                                                                      void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_index_find(HashTable const   *ht ,
                                                                            ulong h ,
                                                                            void **pData ) ;
__inline static int zend_symtable_find(HashTable *ht , char const   *arKey ,
                                       uint nKeyLength , void **pData ) 
{ ulong idx ;
  register char const   *tmp ;
  char const   *end ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "474\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "473\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "470\n");
      fflush(_coverage_fout);
      }
      tmp = arKey;
      {
      fprintf(_coverage_fout, "471\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        fprintf(_coverage_fout, "438\n");
        fflush(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        fprintf(_coverage_fout, "439\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "472\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        fprintf(_coverage_fout, "468\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          fprintf(_coverage_fout, "462\n");
          fflush(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          fprintf(_coverage_fout, "463\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "446\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              fprintf(_coverage_fout, "440\n");
              fflush(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              fprintf(_coverage_fout, "445\n");
              fflush(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "444\n");
                fflush(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  fprintf(_coverage_fout, "442\n");
                  fflush(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    fprintf(_coverage_fout, "441\n");
                    fflush(_coverage_fout);
                    }

                  }
                } else {
                  {
                  fprintf(_coverage_fout, "443\n");
                  fflush(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          fprintf(_coverage_fout, "464\n");
          fflush(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          fprintf(_coverage_fout, "465\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "450\n");
            fflush(_coverage_fout);
            }
            tmp ++;
            {
            fprintf(_coverage_fout, "451\n");
            fflush(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              fprintf(_coverage_fout, "449\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                fprintf(_coverage_fout, "448\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  fprintf(_coverage_fout, "447\n");
                  fflush(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "452\n");
            fflush(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          fprintf(_coverage_fout, "466\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            fprintf(_coverage_fout, "458\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              fprintf(_coverage_fout, "454\n");
              fflush(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "453\n");
                fflush(_coverage_fout);
                }

              }
              {
              fprintf(_coverage_fout, "455\n");
              fflush(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              fprintf(_coverage_fout, "457\n");
              fflush(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "456\n");
                fflush(_coverage_fout);
                }

              }
            }
            {
            fprintf(_coverage_fout, "459\n");
            fflush(_coverage_fout);
            }
            tmp___0 = zend_hash_index_find((HashTable const   *)ht, idx, pData);
            {
            fprintf(_coverage_fout, "460\n");
            fflush(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            fprintf(_coverage_fout, "461\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "467\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "469\n");
        fflush(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  fprintf(_coverage_fout, "475\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_hash_find((HashTable const   *)ht, arKey, nKeyLength, pData);
  {
  fprintf(_coverage_fout, "476\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__inline static int zend_symtable_find(HashTable *ht , char const   *arKey ,
                                       uint nKeyLength , void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_del_key_or_index(HashTable *ht ,
                                                                                  char const   *arKey ,
                                                                                  uint nKeyLength ,
                                                                                  ulong h ,
                                                                                  int flag ) ;
__inline static int zend_symtable_del(HashTable *ht , char const   *arKey ,
                                      uint nKeyLength ) 
{ ulong idx ;
  register char const   *tmp ;
  char const   *end ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "435\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "434\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "431\n");
      fflush(_coverage_fout);
      }
      tmp = arKey;
      {
      fprintf(_coverage_fout, "432\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        fprintf(_coverage_fout, "399\n");
        fflush(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        fprintf(_coverage_fout, "400\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "433\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        fprintf(_coverage_fout, "429\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          fprintf(_coverage_fout, "423\n");
          fflush(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          fprintf(_coverage_fout, "424\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "407\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              fprintf(_coverage_fout, "401\n");
              fflush(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              fprintf(_coverage_fout, "406\n");
              fflush(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "405\n");
                fflush(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  fprintf(_coverage_fout, "403\n");
                  fflush(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    fprintf(_coverage_fout, "402\n");
                    fflush(_coverage_fout);
                    }

                  }
                } else {
                  {
                  fprintf(_coverage_fout, "404\n");
                  fflush(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          fprintf(_coverage_fout, "425\n");
          fflush(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          fprintf(_coverage_fout, "426\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "411\n");
            fflush(_coverage_fout);
            }
            tmp ++;
            {
            fprintf(_coverage_fout, "412\n");
            fflush(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              fprintf(_coverage_fout, "410\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                fprintf(_coverage_fout, "409\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  fprintf(_coverage_fout, "408\n");
                  fflush(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "413\n");
            fflush(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          fprintf(_coverage_fout, "427\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            fprintf(_coverage_fout, "419\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              fprintf(_coverage_fout, "415\n");
              fflush(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "414\n");
                fflush(_coverage_fout);
                }

              }
              {
              fprintf(_coverage_fout, "416\n");
              fflush(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              fprintf(_coverage_fout, "418\n");
              fflush(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "417\n");
                fflush(_coverage_fout);
                }

              }
            }
            {
            fprintf(_coverage_fout, "420\n");
            fflush(_coverage_fout);
            }
            tmp___0 = zend_hash_del_key_or_index(ht,
                                                 (char const   *)((void *)0),
                                                 0U, idx, 1);
            {
            fprintf(_coverage_fout, "421\n");
            fflush(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            fprintf(_coverage_fout, "422\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "428\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "430\n");
        fflush(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  fprintf(_coverage_fout, "436\n");
  fflush(_coverage_fout);
  }
  tmp___1 = zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0UL, 0);
  {
  fprintf(_coverage_fout, "437\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__inline static int zend_symtable_del(HashTable *ht , char const   *arKey ,
                                      uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  _zend_hash_add_or_update(HashTable *ht ,
                                                                                char const   *arKey ,
                                                                                uint nKeyLength ,
                                                                                void *pData ,
                                                                                uint nDataSize ,
                                                                                void **pDest ,
                                                                                int flag ) ;
extern int __attribute__((__visibility__("default")))  _zend_hash_index_update_or_next_insert(HashTable *ht ,
                                                                                              ulong h ,
                                                                                              void *pData ,
                                                                                              uint nDataSize ,
                                                                                              void **pDest ,
                                                                                              int flag ) ;
__inline static int zend_symtable_update(HashTable *ht , char const   *arKey ,
                                         uint nKeyLength , void *pData ,
                                         uint nDataSize , void **pDest ) 
{ ulong idx ;
  register char const   *tmp ;
  char const   *end ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "396\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "395\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "392\n");
      fflush(_coverage_fout);
      }
      tmp = arKey;
      {
      fprintf(_coverage_fout, "393\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        fprintf(_coverage_fout, "360\n");
        fflush(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        fprintf(_coverage_fout, "361\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "394\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        fprintf(_coverage_fout, "390\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          fprintf(_coverage_fout, "384\n");
          fflush(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          fprintf(_coverage_fout, "385\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "368\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              fprintf(_coverage_fout, "362\n");
              fflush(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              fprintf(_coverage_fout, "367\n");
              fflush(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "366\n");
                fflush(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  fprintf(_coverage_fout, "364\n");
                  fflush(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    fprintf(_coverage_fout, "363\n");
                    fflush(_coverage_fout);
                    }

                  }
                } else {
                  {
                  fprintf(_coverage_fout, "365\n");
                  fflush(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          fprintf(_coverage_fout, "386\n");
          fflush(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          fprintf(_coverage_fout, "387\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "372\n");
            fflush(_coverage_fout);
            }
            tmp ++;
            {
            fprintf(_coverage_fout, "373\n");
            fflush(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              fprintf(_coverage_fout, "371\n");
              fflush(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                fprintf(_coverage_fout, "370\n");
                fflush(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  fprintf(_coverage_fout, "369\n");
                  fflush(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "374\n");
            fflush(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          fprintf(_coverage_fout, "388\n");
          fflush(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            fprintf(_coverage_fout, "380\n");
            fflush(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              fprintf(_coverage_fout, "376\n");
              fflush(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "375\n");
                fflush(_coverage_fout);
                }

              }
              {
              fprintf(_coverage_fout, "377\n");
              fflush(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              fprintf(_coverage_fout, "379\n");
              fflush(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                fprintf(_coverage_fout, "378\n");
                fflush(_coverage_fout);
                }

              }
            }
            {
            fprintf(_coverage_fout, "381\n");
            fflush(_coverage_fout);
            }
            tmp___0 = _zend_hash_index_update_or_next_insert(ht, idx, pData,
                                                             nDataSize, pDest, 1);
            {
            fprintf(_coverage_fout, "382\n");
            fflush(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            fprintf(_coverage_fout, "383\n");
            fflush(_coverage_fout);
            }

          }
        } else {
          {
          fprintf(_coverage_fout, "389\n");
          fflush(_coverage_fout);
          }

        }
      } else {
        {
        fprintf(_coverage_fout, "391\n");
        fflush(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  fprintf(_coverage_fout, "397\n");
  fflush(_coverage_fout);
  }
  tmp___1 = _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize,
                                     pDest, 1);
  {
  fprintf(_coverage_fout, "398\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__inline static int zend_symtable_update(HashTable *ht , char const   *arKey ,
                                         uint nKeyLength , void *pData ,
                                         uint nDataSize , void **pDest ) ;
extern ulong __attribute__((__visibility__("default")))  zend_hash_func(char const   *arKey ,
                                                                        uint nKeyLength ) ;
__inline static ulong zend_inline_hash_func(char const   *arKey ,
                                            uint nKeyLength ) 
{ register ulong hash ;
  char const   *tmp ;
  char const   *tmp___0 ;
  char const   *tmp___1 ;
  char const   *tmp___2 ;
  char const   *tmp___3 ;
  char const   *tmp___4 ;
  char const   *tmp___5 ;
  char const   *tmp___6 ;
  char const   *tmp___7 ;
  char const   *tmp___8 ;
  char const   *tmp___9 ;
  char const   *tmp___10 ;
  char const   *tmp___11 ;
  char const   *tmp___12 ;
  char const   *tmp___13 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "357\n");
  fflush(_coverage_fout);
  }
  hash = (ulong )5381;
  {
  fprintf(_coverage_fout, "358\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "310\n");
    fflush(_coverage_fout);
    }
    if (nKeyLength >= 8U) {
      {
      fprintf(_coverage_fout, "309\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "311\n");
    fflush(_coverage_fout);
    }
    tmp = arKey;
    {
    fprintf(_coverage_fout, "312\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "313\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp;
    {
    fprintf(_coverage_fout, "314\n");
    fflush(_coverage_fout);
    }
    tmp___0 = arKey;
    {
    fprintf(_coverage_fout, "315\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "316\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___0;
    {
    fprintf(_coverage_fout, "317\n");
    fflush(_coverage_fout);
    }
    tmp___1 = arKey;
    {
    fprintf(_coverage_fout, "318\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "319\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___1;
    {
    fprintf(_coverage_fout, "320\n");
    fflush(_coverage_fout);
    }
    tmp___2 = arKey;
    {
    fprintf(_coverage_fout, "321\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "322\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___2;
    {
    fprintf(_coverage_fout, "323\n");
    fflush(_coverage_fout);
    }
    tmp___3 = arKey;
    {
    fprintf(_coverage_fout, "324\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "325\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___3;
    {
    fprintf(_coverage_fout, "326\n");
    fflush(_coverage_fout);
    }
    tmp___4 = arKey;
    {
    fprintf(_coverage_fout, "327\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "328\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___4;
    {
    fprintf(_coverage_fout, "329\n");
    fflush(_coverage_fout);
    }
    tmp___5 = arKey;
    {
    fprintf(_coverage_fout, "330\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "331\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___5;
    {
    fprintf(_coverage_fout, "332\n");
    fflush(_coverage_fout);
    }
    tmp___6 = arKey;
    {
    fprintf(_coverage_fout, "333\n");
    fflush(_coverage_fout);
    }
    arKey ++;
    {
    fprintf(_coverage_fout, "334\n");
    fflush(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___6;
    {
    fprintf(_coverage_fout, "335\n");
    fflush(_coverage_fout);
    }
    nKeyLength -= 8U;
  }
  switch ((int )nKeyLength) {
  {
  fprintf(_coverage_fout, "336\n");
  fflush(_coverage_fout);
  }
  case 7: 
  tmp___7 = arKey;
  {
  fprintf(_coverage_fout, "337\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "338\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___7;
  {
  fprintf(_coverage_fout, "339\n");
  fflush(_coverage_fout);
  }
  case 6: 
  tmp___8 = arKey;
  {
  fprintf(_coverage_fout, "340\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "341\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___8;
  {
  fprintf(_coverage_fout, "342\n");
  fflush(_coverage_fout);
  }
  case 5: 
  tmp___9 = arKey;
  {
  fprintf(_coverage_fout, "343\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "344\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___9;
  {
  fprintf(_coverage_fout, "345\n");
  fflush(_coverage_fout);
  }
  case 4: 
  tmp___10 = arKey;
  {
  fprintf(_coverage_fout, "346\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "347\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___10;
  {
  fprintf(_coverage_fout, "348\n");
  fflush(_coverage_fout);
  }
  case 3: 
  tmp___11 = arKey;
  {
  fprintf(_coverage_fout, "349\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "350\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___11;
  {
  fprintf(_coverage_fout, "351\n");
  fflush(_coverage_fout);
  }
  case 2: 
  tmp___12 = arKey;
  {
  fprintf(_coverage_fout, "352\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "353\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___12;
  {
  fprintf(_coverage_fout, "354\n");
  fflush(_coverage_fout);
  }
  case 1: 
  tmp___13 = arKey;
  {
  fprintf(_coverage_fout, "355\n");
  fflush(_coverage_fout);
  }
  arKey ++;
  {
  fprintf(_coverage_fout, "356\n");
  fflush(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___13;
  break;
  case 0: 
  break;
  }
  {
  fprintf(_coverage_fout, "359\n");
  fflush(_coverage_fout);
  }
  return (hash);
}
}
__inline static ulong zend_inline_hash_func(char const   *arKey ,
                                            uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_rehash(HashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_minmax(HashTable const   *ht ,
                                                                        int (*compar)(void const   * ,
                                                                                      void const   * ) ,
                                                                        int flag ,
                                                                        void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_compare(HashTable *ht1 ,
                                                                         HashTable *ht2 ,
                                                                         int (*compar)(void const   * ,
                                                                                       void const   * ) ,
                                                                         zend_bool ordered ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_sort(HashTable *ht ,
                                                                      void (*sort_func)(void * ,
                                                                                        size_t  ,
                                                                                        size_t  ,
                                                                                        int (*)(void const   * ,
                                                                                                void const   * ) ) ,
                                                                      int (*compare_func)(void const   * ,
                                                                                          void const   * ) ,
                                                                      int renumber ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_merge_ex(HashTable *target ,
                                                                           HashTable *source ,
                                                                           void (*pCopyConstructor)(void *pElement ) ,
                                                                           uint size ,
                                                                           zend_bool (*pMergeSource)(HashTable *target_ht ,
                                                                                                     void *source_data ,
                                                                                                     zend_hash_key *hash_key ,
                                                                                                     void *pParam ) ,
                                                                           void *pParam ) ;
extern void __attribute__((__visibility__("default")))  _zend_hash_merge(HashTable *target ,
                                                                         HashTable *source ,
                                                                         void (*pCopyConstructor)(void *pElement ) ,
                                                                         void *tmp ,
                                                                         uint size ,
                                                                         int overwrite ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_copy(HashTable *target ,
                                                                       HashTable *source ,
                                                                       void (*pCopyConstructor)(void *pElement ) ,
                                                                       void *tmp ,
                                                                       uint size ) ;
struct _HashPointer;
typedef struct _HashPointer HashPointer;
extern int __attribute__((__visibility__("default")))  zend_hash_set_pointer(HashTable *ht ,
                                                                             HashPointer const   *ptr ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_get_pointer(HashTable const   *ht ,
                                                                             HashPointer *ptr ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_internal_pointer_end_ex(HashTable *ht ,
                                                                                          HashPosition *pos ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_internal_pointer_reset_ex(HashTable *ht ,
                                                                                            HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_get_current_data_ex(HashTable *ht ,
                                                                                     void **pData ,
                                                                                     HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_get_current_key_type_ex(HashTable *ht ,
                                                                                         HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_get_current_key_ex(HashTable const   *ht ,
                                                                                    char **str_index ,
                                                                                    uint *str_length ,
                                                                                    ulong *num_index ,
                                                                                    zend_bool duplicate ,
                                                                                    HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_move_backwards_ex(HashTable *ht ,
                                                                                   HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_move_forward_ex(HashTable *ht ,
                                                                                 HashPosition *pos ) ;
extern ulong __attribute__((__visibility__("default")))  zend_hash_next_free_element(HashTable const   *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_quick_exists(HashTable const   *ht ,
                                                                              char const   *arKey ,
                                                                              uint nKeyLength ,
                                                                              ulong h ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_quick_find(HashTable const   *ht ,
                                                                            char const   *arKey ,
                                                                            uint nKeyLength ,
                                                                            ulong h ,
                                                                            void **pData ) ;
extern ulong __attribute__((__visibility__("default")))  zend_get_hash_value(char const   *arKey ,
                                                                             uint nKeyLength ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_reverse_apply(HashTable *ht ,
                                                                                int (*apply_func)(void *pDest ) ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_apply_with_arguments(HashTable *ht ,
                                                                                       int (*apply_func)(void *pDest ,
                                                                                                         int num_args ,
                                                                                                         va_list args ,
                                                                                                         zend_hash_key *hash_key ) ,
                                                                                       int  
                                                                                       , ...) ;
extern void __attribute__((__visibility__("default")))  zend_hash_apply_with_argument(HashTable *ht ,
                                                                                      int (*apply_func)(void *pDest ,
                                                                                                        void *argument ) ,
                                                                                      void * ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_apply(HashTable *ht ,
                                                                        int (*apply_func)(void *pDest ) ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_graceful_reverse_destroy(HashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_graceful_destroy(HashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_add_empty_element(HashTable *ht ,
                                                                                   char const   *arKey ,
                                                                                   uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  _zend_hash_quick_add_or_update(HashTable *ht ,
                                                                                      char const   *arKey ,
                                                                                      uint nKeyLength ,
                                                                                      ulong h ,
                                                                                      void *pData ,
                                                                                      uint nDataSize ,
                                                                                      void **pDest ,
                                                                                      int flag ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_clean(HashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_destroy(HashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  _zend_hash_init_ex(HashTable *ht ,
                                                                          uint nSize ,
                                                                          ulong (*pHashFunction)(char const   *arKey ,
                                                                                                 uint nKeyLength ) ,
                                                                          void (*pDestructor)(void *pDest ) ,
                                                                          zend_bool persistent ,
                                                                          zend_bool bApplyProtection ) ;
extern int __attribute__((__visibility__("default")))  _zend_hash_init(HashTable *ht ,
                                                                       uint nSize ,
                                                                       ulong (*pHashFunction)(char const   *arKey ,
                                                                                              uint nKeyLength ) ,
                                                                       void (*pDestructor)(void *pDest ) ,
                                                                       zend_bool persistent ) ;
static char const   long_min_digits[11]  = 
  {      (char const   )'2',      (char const   )'1',      (char const   )'4',      (char const   )'7', 
        (char const   )'4',      (char const   )'8',      (char const   )'3',      (char const   )'6', 
        (char const   )'4',      (char const   )'8',      (char const   )'\000'};
extern void zend_interned_strings_dtor(void) ;
extern void zend_interned_strings_init(void) ;
extern void __attribute__((__visibility__("default")))  (*zend_interned_strings_restore)(void) ;
extern void __attribute__((__visibility__("default")))  (*zend_interned_strings_snapshot)(void) ;
extern char const __attribute__((__visibility__("default")))  *(*zend_new_interned_string)(char const   *str ,
                                                                                           int len ,
                                                                                           int free_src ) ;
struct _zend_mm_heap;
typedef struct _zend_mm_heap zend_mm_heap;
extern void __attribute__((__visibility__("default")))  zend_mm_set_custom_handlers(zend_mm_heap *heap ,
                                                                                    void *(*_malloc)(size_t  ) ,
                                                                                    void (*_free)(void * ) ,
                                                                                    void *(*_realloc)(void * ,
                                                                                                      size_t  ) ) ;
struct _zend_mm_storage;
typedef struct _zend_mm_storage zend_mm_storage;
extern zend_mm_storage __attribute__((__visibility__("default")))  *zend_mm_get_storage(zend_mm_heap *heap ) ;
extern zend_mm_heap __attribute__((__visibility__("default")))  *zend_mm_set_heap(zend_mm_heap *new_heap ) ;
struct _zend_mm_mem_handlers;
typedef struct _zend_mm_mem_handlers zend_mm_mem_handlers;
extern zend_mm_heap __attribute__((__visibility__("default")))  *zend_mm_startup_ex(zend_mm_mem_handlers const   *handlers ,
                                                                                    size_t block_size ,
                                                                                    size_t reserve_size ,
                                                                                    int internal ,
                                                                                    void *params ) ;
extern size_t __attribute__((__visibility__("default")))  _zend_mm_block_size(zend_mm_heap *heap ,
                                                                              void *p ) ;
extern void __attribute__((__visibility__("default")))  *_zend_mm_realloc(zend_mm_heap *heap ,
                                                                          void *p ,
                                                                          size_t size ) ;
extern void __attribute__((__visibility__("default")))  _zend_mm_free(zend_mm_heap *heap ,
                                                                      void *p ) ;
extern void __attribute__((__visibility__("default")))  *_zend_mm_alloc(zend_mm_heap *heap ,
                                                                        size_t size )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  zend_mm_shutdown(zend_mm_heap *heap ,
                                                                         int full_shutdown ,
                                                                         int silent ) ;
extern zend_mm_heap __attribute__((__visibility__("default")))  *zend_mm_startup(void) ;
extern size_t __attribute__((__visibility__("default")))  zend_memory_peak_usage(int real_usage ) ;
extern size_t __attribute__((__visibility__("default")))  zend_memory_usage(int real_usage ) ;
extern int __attribute__((__visibility__("default")))  is_zend_mm(void) ;
extern void __attribute__((__visibility__("default")))  shutdown_memory_manager(int silent ,
                                                                                int full_shutdown ) ;
extern void __attribute__((__visibility__("default")))  start_memory_manager(void) ;
extern int __attribute__((__visibility__("default")))  zend_set_memory_limit(size_t memory_limit ) ;
extern  __attribute__((__nothrow__, __noreturn__)) void exit(int __status ) ;
extern struct _IO_FILE *stderr ;
extern  __attribute__((__nothrow__)) void *realloc(void *__ptr , size_t __size )  __attribute__((__warn_unused_result__)) ;
__inline static void *__zend_realloc(void *p , size_t len ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "305\n");
  fflush(_coverage_fout);
  }
  p = realloc(p, len);
  {
  fprintf(_coverage_fout, "306\n");
  fflush(_coverage_fout);
  }
  if (p) {
    {
    fprintf(_coverage_fout, "303\n");
    fflush(_coverage_fout);
    }
    return (p);
  } else {
    {
    fprintf(_coverage_fout, "304\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "307\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stderr,
          (char const   */* __restrict  */)"Out of memory\n");
  {
  fprintf(_coverage_fout, "308\n");
  fflush(_coverage_fout);
  }
  exit(1);
}
}
extern  __attribute__((__nothrow__)) void *memset(void *__s , int __c ,
                                                  size_t __n )  __attribute__((__nonnull__(1))) ;
extern void __attribute__((__visibility__("default")))  *_safe_malloc(size_t nmemb ,
                                                                      size_t size ,
                                                                      size_t offset )  __attribute__((__malloc__)) ;
__inline static void *__zend_calloc(size_t nmemb , size_t len ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "299\n");
  fflush(_coverage_fout);
  }
  tmp___0 = _safe_malloc(nmemb, len, 0U);
  {
  fprintf(_coverage_fout, "300\n");
  fflush(_coverage_fout);
  }
  tmp = (void *)tmp___0;
  {
  fprintf(_coverage_fout, "301\n");
  fflush(_coverage_fout);
  }
  memset(tmp, 0, nmemb * len);
  {
  fprintf(_coverage_fout, "302\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline static void *__zend_calloc(size_t nmemb , size_t len ) ;
extern  __attribute__((__nothrow__)) void *malloc(size_t __size )  __attribute__((__malloc__)) ;
__inline static void *__zend_malloc(size_t len ) 
{ void *tmp ;
  void *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "294\n");
  fflush(_coverage_fout);
  }
  tmp___0 = malloc(len);
  {
  fprintf(_coverage_fout, "295\n");
  fflush(_coverage_fout);
  }
  tmp = tmp___0;
  {
  fprintf(_coverage_fout, "296\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "292\n");
    fflush(_coverage_fout);
    }
    return (tmp);
  } else {
    {
    fprintf(_coverage_fout, "293\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "297\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stderr,
          (char const   */* __restrict  */)"Out of memory\n");
  {
  fprintf(_coverage_fout, "298\n");
  fflush(_coverage_fout);
  }
  exit(1);
}
}
__inline static void *__zend_malloc(size_t len ) ;
extern size_t __attribute__((__visibility__("default")))  _zend_mem_block_size(void *ptr ) ;
extern char __attribute__((__visibility__("default")))  *_estrdup(char const   *s )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  *_safe_realloc(void *ptr ,
                                                                       size_t nmemb ,
                                                                       size_t size ,
                                                                       size_t offset ) ;
extern void __attribute__((__visibility__("default")))  *_safe_erealloc(void *ptr ,
                                                                        size_t nmemb ,
                                                                        size_t size ,
                                                                        size_t offset ) ;
extern void __attribute__((__visibility__("default")))  *_ecalloc(size_t nmemb ,
                                                                  size_t size )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  *_safe_emalloc(size_t nmemb ,
                                                                       size_t size ,
                                                                       size_t offset )  __attribute__((__malloc__)) ;
extern char __attribute__((__visibility__("default")))  *zend_strndup(char const   *s ,
                                                                      unsigned int length )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) int dlinfo(void * __restrict  __handle ,
                                                int __request ,
                                                void * __restrict  __arg )  __attribute__((__nonnull__(1,3))) ;
struct __anonstruct_Dl_info_34;
typedef struct __anonstruct_Dl_info_34 Dl_info;
extern  __attribute__((__nothrow__)) int dladdr1(void const   *__address ,
                                                 Dl_info *__info ,
                                                 void **__extra_info ,
                                                 int __flags )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int dladdr(void const   *__address ,
                                                Dl_info *__info )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *dlerror(void) ;
extern  __attribute__((__nothrow__)) void *dlvsym(void * __restrict  __handle ,
                                                  char const   * __restrict  __name ,
                                                  char const   * __restrict  __version )  __attribute__((__nonnull__(2,3))) ;
typedef long Lmid_t;
extern  __attribute__((__nothrow__)) void *dlmopen(Lmid_t __nsid ,
                                                   char const   *__file ,
                                                   int __mode ) ;
extern  __attribute__((__nothrow__)) void *dlsym(void * __restrict  __handle ,
                                                 char const   * __restrict  __name )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int dlclose(void *__handle )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *dlopen(char const   *__file ,
                                                  int __mode ) ;
extern  __attribute__((__nothrow__)) void _dl_mcount_wrapper_check(void *__selfpc ) ;
typedef void _IO_lock_t;
struct _IO_marker;
struct _IO_FILE {
   int _flags ;
   char *_IO_read_ptr ;
   char *_IO_read_end ;
   char *_IO_read_base ;
   char *_IO_write_base ;
   char *_IO_write_ptr ;
   char *_IO_write_end ;
   char *_IO_buf_base ;
   char *_IO_buf_end ;
   char *_IO_save_base ;
   char *_IO_backup_base ;
   char *_IO_save_end ;
   struct _IO_marker *_markers ;
   struct _IO_FILE *_chain ;
   int _fileno ;
   int _flags2 ;
   __off_t _old_offset ;
   unsigned short _cur_column ;
   signed char _vtable_offset ;
   char _shortbuf[1] ;
   _IO_lock_t *_lock ;
   __off64_t _offset ;
   void *__pad1 ;
   void *__pad2 ;
   void *__pad3 ;
   void *__pad4 ;
   size_t __pad5 ;
   int _mode ;
   char _unused2[(15U * sizeof(int ) - 4U * sizeof(void *)) - sizeof(size_t )] ;
};
__inline extern  __attribute__((__nothrow__)) int ferror_unlocked(FILE *__stream ) ;
__inline extern int ferror_unlocked(FILE *__stream ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "291\n");
  fflush(_coverage_fout);
  }
  return ((__stream->_flags & 0x20) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) int ferror_unlocked(FILE *__stream ) ;
__inline extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
__inline extern int feof_unlocked(FILE *__stream ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "290\n");
  fflush(_coverage_fout);
  }
  return ((__stream->_flags & 0x10) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
extern __ssize_t __getdelim(char ** __restrict  __lineptr ,
                            size_t * __restrict  __n , int __delimiter ,
                            FILE * __restrict  __stream ) ;
__inline extern __ssize_t getline(char ** __restrict  __lineptr ,
                                  size_t * __restrict  __n ,
                                  FILE * __restrict  __stream ) 
{ __ssize_t tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "288\n");
  fflush(_coverage_fout);
  }
  tmp = __getdelim(__lineptr, __n, '\n', __stream);
  {
  fprintf(_coverage_fout, "289\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern __ssize_t getline(char ** __restrict  __lineptr ,
                                  size_t * __restrict  __n ,
                                  FILE * __restrict  __stream ) ;
extern struct _IO_FILE *stdout ;
typedef struct _IO_FILE _IO_FILE;
extern int __overflow(_IO_FILE * , int  ) ;
__inline extern int putchar_unlocked(int __c ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "285\n");
  fflush(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )stdout->_IO_write_ptr >= (unsigned int )stdout->_IO_write_end),
                             0L);
  {
  fprintf(_coverage_fout, "286\n");
  fflush(_coverage_fout);
  }
  if (tmp___4) {
    {
    fprintf(_coverage_fout, "278\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __overflow(stdout, (int )((unsigned char )__c));
    {
    fprintf(_coverage_fout, "279\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "280\n");
    fflush(_coverage_fout);
    }
    tmp___1 = stdout->_IO_write_ptr;
    {
    fprintf(_coverage_fout, "281\n");
    fflush(_coverage_fout);
    }
    (stdout->_IO_write_ptr) ++;
    {
    fprintf(_coverage_fout, "282\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    fprintf(_coverage_fout, "283\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    fprintf(_coverage_fout, "284\n");
    fflush(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  fprintf(_coverage_fout, "287\n");
  fflush(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern int putchar_unlocked(int __c ) ;
__inline extern int putc_unlocked(int __c , FILE *__stream ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "275\n");
  fflush(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end),
                             0L);
  {
  fprintf(_coverage_fout, "276\n");
  fflush(_coverage_fout);
  }
  if (tmp___4) {
    {
    fprintf(_coverage_fout, "268\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    fprintf(_coverage_fout, "269\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "270\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    fprintf(_coverage_fout, "271\n");
    fflush(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    fprintf(_coverage_fout, "272\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    fprintf(_coverage_fout, "273\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    fprintf(_coverage_fout, "274\n");
    fflush(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  fprintf(_coverage_fout, "277\n");
  fflush(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern int putc_unlocked(int __c , FILE *__stream ) ;
__inline extern int fputc_unlocked(int __c , FILE *__stream ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "265\n");
  fflush(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end),
                             0L);
  {
  fprintf(_coverage_fout, "266\n");
  fflush(_coverage_fout);
  }
  if (tmp___4) {
    {
    fprintf(_coverage_fout, "258\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    fprintf(_coverage_fout, "259\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "260\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    fprintf(_coverage_fout, "261\n");
    fflush(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    fprintf(_coverage_fout, "262\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    fprintf(_coverage_fout, "263\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    fprintf(_coverage_fout, "264\n");
    fflush(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  fprintf(_coverage_fout, "267\n");
  fflush(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern int fputc_unlocked(int __c , FILE *__stream ) ;
extern int _IO_putc(int __c , _IO_FILE *__fp ) ;
__inline extern int putchar(int __c ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "256\n");
  fflush(_coverage_fout);
  }
  tmp = _IO_putc(__c, stdout);
  {
  fprintf(_coverage_fout, "257\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int putchar(int __c ) ;
extern struct _IO_FILE *stdin ;
extern int __uflow(_IO_FILE * ) ;
__inline extern int getchar_unlocked(void) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "253\n");
  fflush(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )stdin->_IO_read_ptr >= (unsigned int )stdin->_IO_read_end),
                             0L);
  {
  fprintf(_coverage_fout, "254\n");
  fflush(_coverage_fout);
  }
  if (tmp___3) {
    {
    fprintf(_coverage_fout, "248\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __uflow(stdin);
    {
    fprintf(_coverage_fout, "249\n");
    fflush(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "250\n");
    fflush(_coverage_fout);
    }
    tmp___1 = stdin->_IO_read_ptr;
    {
    fprintf(_coverage_fout, "251\n");
    fflush(_coverage_fout);
    }
    (stdin->_IO_read_ptr) ++;
    {
    fprintf(_coverage_fout, "252\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  fprintf(_coverage_fout, "255\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int getchar_unlocked(void) ;
__inline extern int getc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "245\n");
  fflush(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end),
                             0L);
  {
  fprintf(_coverage_fout, "246\n");
  fflush(_coverage_fout);
  }
  if (tmp___3) {
    {
    fprintf(_coverage_fout, "240\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    fprintf(_coverage_fout, "241\n");
    fflush(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "242\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    fprintf(_coverage_fout, "243\n");
    fflush(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    fprintf(_coverage_fout, "244\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  fprintf(_coverage_fout, "247\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int getc_unlocked(FILE *__fp ) ;
__inline extern int fgetc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "237\n");
  fflush(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end),
                             0L);
  {
  fprintf(_coverage_fout, "238\n");
  fflush(_coverage_fout);
  }
  if (tmp___3) {
    {
    fprintf(_coverage_fout, "232\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    fprintf(_coverage_fout, "233\n");
    fflush(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "234\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    fprintf(_coverage_fout, "235\n");
    fflush(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    fprintf(_coverage_fout, "236\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  fprintf(_coverage_fout, "239\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int fgetc_unlocked(FILE *__fp ) ;
extern int _IO_getc(_IO_FILE *__fp ) ;
__inline extern int getchar(void) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "230\n");
  fflush(_coverage_fout);
  }
  tmp = _IO_getc(stdin);
  {
  fprintf(_coverage_fout, "231\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int getchar(void) ;
extern int vfprintf(FILE * __restrict  __s ,
                    char const   * __restrict  __format , __gnuc_va_list __arg ) ;
__inline extern int vprintf(char const   * __restrict  __fmt ,
                            __gnuc_va_list __arg ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "228\n");
  fflush(_coverage_fout);
  }
  tmp = vfprintf((FILE */* __restrict  */)stdout, __fmt, __arg);
  {
  fprintf(_coverage_fout, "229\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int vprintf(char const   * __restrict  __fmt ,
                            __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) void funlockfile(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int ftrylockfile(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) void flockfile(FILE *__stream ) ;
struct obstack;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  obstack_vprintf)(struct obstack * __restrict  __obstack ,
                                                                                    char const   * __restrict  __format ,
                                                                                    __gnuc_va_list __args ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  obstack_printf)(struct obstack * __restrict  __obstack ,
                                                                                   char const   * __restrict  __format 
                                                                                   , ...) ;
extern char *cuserid(char *__s ) ;
extern  __attribute__((__nothrow__)) char *ctermid(char *__s ) ;
extern int pclose(FILE *__stream ) ;
extern FILE *popen(char const   *__command , char const   *__modes ) ;
extern  __attribute__((__nothrow__)) int fileno_unlocked(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int fileno(FILE *__stream ) ;
extern char const   * const  _sys_errlist[] ;
extern int _sys_nerr ;
extern char const   * const  sys_errlist[] ;
extern int sys_nerr ;
extern void perror(char const   *__s ) ;
extern  __attribute__((__nothrow__)) void clearerr_unlocked(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int ferror(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int feof(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) void clearerr(FILE *__stream ) ;
struct __anonstruct__G_fpos64_t_32;
typedef struct __anonstruct__G_fpos64_t_32 _G_fpos64_t;
typedef _G_fpos64_t fpos64_t;
extern int fsetpos64(FILE *__stream , fpos64_t const   *__pos ) ;
extern int fgetpos64(FILE * __restrict  __stream , fpos64_t * __restrict  __pos ) ;
extern __off64_t ftello64(FILE *__stream ) ;
extern int fseeko64(FILE *__stream , __off64_t __off , int __whence ) ;
struct __anonstruct__G_fpos_t_31;
typedef struct __anonstruct__G_fpos_t_31 _G_fpos_t;
typedef _G_fpos_t fpos_t;
extern int fsetpos(FILE *__stream , fpos_t const   *__pos ) ;
extern int fgetpos(FILE * __restrict  __stream , fpos_t * __restrict  __pos ) ;
extern __off_t ftello(FILE *__stream ) ;
extern int fseeko(FILE *__stream , __off_t __off , int __whence ) ;
extern void rewind(FILE *__stream ) ;
extern long ftell(FILE *__stream ) ;
extern int fseek(FILE *__stream , long __off , int __whence ) ;
extern size_t fwrite_unlocked(void const   * __restrict  __ptr , size_t __size ,
                              size_t __n , FILE * __restrict  __stream ) ;
extern size_t fread_unlocked(void * __restrict  __ptr , size_t __size ,
                             size_t __n , FILE * __restrict  __stream ) ;
extern int fputs_unlocked(char const   * __restrict  __s ,
                          FILE * __restrict  __stream ) ;
extern size_t fwrite(void const   * __restrict  __ptr , size_t __size ,
                     size_t __n , FILE * __restrict  __s ) ;
extern size_t fread(void * __restrict  __ptr , size_t __size , size_t __n ,
                    FILE * __restrict  __stream ) ;
extern int ungetc(int __c , FILE *__stream ) ;
extern int puts(char const   *__s ) ;
extern int fputs(char const   * __restrict  __s , FILE * __restrict  __stream ) ;
extern __ssize_t getdelim(char ** __restrict  __lineptr ,
                          size_t * __restrict  __n , int __delimiter ,
                          FILE * __restrict  __stream ) ;
extern char *fgets_unlocked(char * __restrict  __s , int __n ,
                            FILE * __restrict  __stream ) ;
extern char *gets(char *__s ) ;
extern char *fgets(char * __restrict  __s , int __n ,
                   FILE * __restrict  __stream ) ;
extern int putw(int __w , FILE *__stream ) ;
extern int getw(FILE *__stream ) ;
extern int putc(int __c , FILE *__stream ) ;
extern int fputc(int __c , FILE *__stream ) ;
extern int getc(FILE *__stream ) ;
extern int fgetc(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vsscanf)(char const   * __restrict  __s ,
                                                                            char const   * __restrict  __format ,
                                                                            __gnuc_va_list __arg ) ;
extern int ( /* format attribute */  vscanf)(char const   * __restrict  __format ,
                                             __gnuc_va_list __arg ) ;
extern int ( /* format attribute */  vfscanf)(FILE * __restrict  __s ,
                                              char const   * __restrict  __format ,
                                              __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int sscanf(char const   * __restrict  __s ,
                                                char const   * __restrict  __format 
                                                , ...) ;
extern int scanf(char const   * __restrict  __format  , ...) ;
extern int fscanf(FILE * __restrict  __stream ,
                  char const   * __restrict  __format  , ...) ;
extern int ( /* format attribute */  dprintf)(int __fd ,
                                              char const   * __restrict  __fmt 
                                              , ...) ;
extern int ( /* format attribute */  vdprintf)(int __fd ,
                                               char const   * __restrict  __fmt ,
                                               __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  asprintf)(char ** __restrict  __ptr ,
                                                                             char const   * __restrict  __fmt 
                                                                             , ...) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  __asprintf)(char ** __restrict  __ptr ,
                                                                               char const   * __restrict  __fmt 
                                                                               , ...) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vasprintf)(char ** __restrict  __ptr ,
                                                                              char const   * __restrict  __f ,
                                                                              __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vsnprintf)(char * __restrict  __s ,
                                                                              size_t __maxlen ,
                                                                              char const   * __restrict  __format ,
                                                                              __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  snprintf)(char * __restrict  __s ,
                                                                             size_t __maxlen ,
                                                                             char const   * __restrict  __format 
                                                                             , ...) ;
extern  __attribute__((__nothrow__)) int vsprintf(char * __restrict  __s ,
                                                  char const   * __restrict  __format ,
                                                  __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int sprintf(char * __restrict  __s ,
                                                 char const   * __restrict  __format 
                                                 , ...) ;
extern int printf(char const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) void setlinebuf(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) void setbuffer(FILE * __restrict  __stream ,
                                                    char * __restrict  __buf ,
                                                    size_t __size ) ;
extern  __attribute__((__nothrow__)) int setvbuf(FILE * __restrict  __stream ,
                                                 char * __restrict  __buf ,
                                                 int __modes , size_t __n ) ;
extern  __attribute__((__nothrow__)) void setbuf(FILE * __restrict  __stream ,
                                                 char * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) FILE *open_memstream(char **__bufloc ,
                                                          size_t *__sizeloc ) ;
extern  __attribute__((__nothrow__)) FILE *fmemopen(void *__s , size_t __len ,
                                                    char const   *__modes ) ;
struct __anonstruct__IO_cookie_io_functions_t_33;
typedef struct __anonstruct__IO_cookie_io_functions_t_33 _IO_cookie_io_functions_t;
extern  __attribute__((__nothrow__)) FILE *fopencookie(void * __restrict  __magic_cookie ,
                                                       char const   * __restrict  __modes ,
                                                       _IO_cookie_io_functions_t __io_funcs ) ;
extern  __attribute__((__nothrow__)) FILE *fdopen(int __fd ,
                                                  char const   *__modes ) ;
extern FILE *freopen64(char const   * __restrict  __filename ,
                       char const   * __restrict  __modes ,
                       FILE * __restrict  __stream ) ;
extern FILE *fopen64(char const   * __restrict  __filename ,
                     char const   * __restrict  __modes ) ;
extern FILE *freopen(char const   * __restrict  __filename ,
                     char const   * __restrict  __modes ,
                     FILE * __restrict  __stream ) ;
extern int fcloseall(void) ;
extern int fflush_unlocked(FILE *__stream ) ;
extern int fclose(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) char *tempnam(char const   *__dir ,
                                                   char const   *__pfx )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) char *tmpnam_r(char *__s ) ;
extern  __attribute__((__nothrow__)) char *tmpnam(char *__s ) ;
extern FILE *tmpfile64(void) ;
extern FILE *tmpfile(void) ;
extern  __attribute__((__nothrow__)) int renameat(int __oldfd ,
                                                  char const   *__old ,
                                                  int __newfd ,
                                                  char const   *__new ) ;
extern  __attribute__((__nothrow__)) int rename(char const   *__old ,
                                                char const   *__new ) ;
extern  __attribute__((__nothrow__)) int remove(char const   *__filename ) ;
extern  __attribute__((__nothrow__)) void _IO_free_backup_area(_IO_FILE * ) ;
extern __off64_t _IO_seekpos(_IO_FILE * , __off64_t  , int  ) ;
extern __off64_t _IO_seekoff(_IO_FILE * , __off64_t  , int  , int  ) ;
extern size_t _IO_sgetn(_IO_FILE * , void * , size_t  ) ;
extern __ssize_t _IO_padn(_IO_FILE * , int  , __ssize_t  ) ;
extern int _IO_vfprintf(_IO_FILE * __restrict   , char const   * __restrict   ,
                        __gnuc_va_list  ) ;
extern int _IO_vfscanf(_IO_FILE * __restrict   , char const   * __restrict   ,
                       __gnuc_va_list  , int * __restrict   ) ;
extern  __attribute__((__nothrow__)) int _IO_ftrylockfile(_IO_FILE * ) ;
extern  __attribute__((__nothrow__)) void _IO_funlockfile(_IO_FILE * ) ;
extern  __attribute__((__nothrow__)) void _IO_flockfile(_IO_FILE * ) ;
extern int _IO_peekc_locked(_IO_FILE *__fp ) ;
extern  __attribute__((__nothrow__)) int _IO_ferror(_IO_FILE *__fp ) ;
extern  __attribute__((__nothrow__)) int _IO_feof(_IO_FILE *__fp ) ;
extern int __underflow(_IO_FILE * ) ;
struct _IO_cookie_file;
extern void _IO_cookie_init(struct _IO_cookie_file *__cfile , int __read_write ,
                            void *__cookie , _IO_cookie_io_functions_t __fns ) ;
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stderr_ ;
extern struct _IO_FILE_plus _IO_2_1_stdout_ ;
extern struct _IO_FILE_plus _IO_2_1_stdin_ ;
union __anonunion_28 {
   double __d ;
   int __i[2] ;
};
__inline extern  __attribute__((__nothrow__)) int __finite(double __x )  __attribute__((__const__)) ;
__inline extern int __finite(double __x ) 
{ union __anonunion_28 __constr_expr_0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "226\n");
  fflush(_coverage_fout);
  }
  __constr_expr_0.__d = __x;
  {
  fprintf(_coverage_fout, "227\n");
  fflush(_coverage_fout);
  }
  return ((int )((((unsigned int )__constr_expr_0.__i[1] | 0x800fffffu) + 1U) >> 31));
}
}
__inline extern  __attribute__((__nothrow__)) int __finite(double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) long long llrintl(long double __x ) ;
__inline extern long long llrintl(long double __x ) 
{ long long __llrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "224\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "225\n");
  fflush(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintl(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long long llrint(double __x ) ;
__inline extern long long llrint(double __x ) 
{ long long __llrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "222\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "223\n");
  fflush(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrint(double __x ) ;
__inline extern  __attribute__((__nothrow__)) long long llrintf(float __x ) ;
__inline extern long long llrintf(float __x ) 
{ long long __llrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "220\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "221\n");
  fflush(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) long lrintl(long double __x ) ;
__inline extern long lrintl(long double __x ) 
{ long __lrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "218\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "219\n");
  fflush(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintl(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long lrint(double __x ) ;
__inline extern long lrint(double __x ) 
{ long __lrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "216\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "217\n");
  fflush(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrint(double __x ) ;
__inline extern  __attribute__((__nothrow__)) long lrintf(float __x ) ;
__inline extern long lrintf(float __x ) 
{ long __lrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "214\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "215\n");
  fflush(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) long double ceill(long double __x )  __attribute__((__const__)) ;
__inline extern long double ceill(long double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "212\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0800, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "213\n");
  fflush(_coverage_fout);
  }
  return (__value);
}
}
__inline extern  __attribute__((__nothrow__)) long double ceill(long double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) float ceilf(float __x )  __attribute__((__const__)) ;
__inline extern float ceilf(float __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "210\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0800, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "211\n");
  fflush(_coverage_fout);
  }
  return ((float )__value);
}
}
__inline extern  __attribute__((__nothrow__)) float ceilf(float __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) double ceil(double __x )  __attribute__((__const__)) ;
__inline extern double ceil(double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "208\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0800, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "209\n");
  fflush(_coverage_fout);
  }
  return ((double )__value);
}
}
__inline extern  __attribute__((__nothrow__)) double ceil(double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) long double floorl(long double __x )  __attribute__((__const__)) ;
__inline extern long double floorl(long double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "206\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0400, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "207\n");
  fflush(_coverage_fout);
  }
  return (__value);
}
}
__inline extern  __attribute__((__nothrow__)) long double floorl(long double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) float floorf(float __x )  __attribute__((__const__)) ;
__inline extern float floorf(float __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "204\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0400, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "205\n");
  fflush(_coverage_fout);
  }
  return ((float )__value);
}
}
__inline extern  __attribute__((__nothrow__)) float floorf(float __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) double floor(double __x )  __attribute__((__const__)) ;
__inline extern double floor(double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "202\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0400, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "203\n");
  fflush(_coverage_fout);
  }
  return ((double )__value);
}
}
__inline extern  __attribute__((__nothrow__)) double floor(double __x )  __attribute__((__const__)) ;
union __anonunion___n_27 {
   long double __xld ;
   unsigned int __xi[3] ;
};
__inline extern  __attribute__((__nothrow__)) long double __sgn1l(long double __x ) ;
__inline extern long double __sgn1l(long double __x ) 
{ union __anonunion___n_27 __n ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "197\n");
  fflush(_coverage_fout);
  }
  __n.__xld = __x;
  {
  fprintf(_coverage_fout, "198\n");
  fflush(_coverage_fout);
  }
  __n.__xi[2] = (__n.__xi[2] & 32768U) | 16383U;
  {
  fprintf(_coverage_fout, "199\n");
  fflush(_coverage_fout);
  }
  __n.__xi[1] = 0x80000000;
  {
  fprintf(_coverage_fout, "200\n");
  fflush(_coverage_fout);
  }
  __n.__xi[0] = 0U;
  {
  fprintf(_coverage_fout, "201\n");
  fflush(_coverage_fout);
  }
  return (__n.__xld);
}
}
__inline extern  __attribute__((__nothrow__)) long double __sgn1l(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double __fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern long double __fabsl(long double __x ) 
{ long double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "195\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  fprintf(_coverage_fout, "196\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double __fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) long double fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern long double fabsl(long double __x ) 
{ long double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "193\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  fprintf(_coverage_fout, "194\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) float fabsf(float __x )  __attribute__((__const__)) ;
__inline extern float fabsf(float __x ) 
{ float tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "191\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabsf(__x);
  {
  fprintf(_coverage_fout, "192\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) float fabsf(float __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) double fabs(double __x )  __attribute__((__const__)) ;
__inline extern double fabs(double __x ) 
{ double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "189\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabs(__x);
  {
  fprintf(_coverage_fout, "190\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) double fabs(double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) long double __atan2l(long double __y ,
                                                                   long double __x ) ;
__inline extern long double __atan2l(long double __y , long double __x ) 
{ long double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "187\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_atan2l(__y, __x);
  {
  fprintf(_coverage_fout, "188\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double __atan2l(long double __y ,
                                                                   long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double __sgnl(long double __x ) ;
__inline extern long double __sgnl(long double __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "185\n");
  fflush(_coverage_fout);
  }
  if (__x == (long double )0.0) {
    {
    fprintf(_coverage_fout, "180\n");
    fflush(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    fprintf(_coverage_fout, "183\n");
    fflush(_coverage_fout);
    }
    if (__x > (long double )0.0) {
      {
      fprintf(_coverage_fout, "181\n");
      fflush(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      fprintf(_coverage_fout, "182\n");
      fflush(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    fprintf(_coverage_fout, "184\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  fprintf(_coverage_fout, "186\n");
  fflush(_coverage_fout);
  }
  return ((long double )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) long double __sgnl(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) float __sgnf(float __x ) ;
__inline extern float __sgnf(float __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "178\n");
  fflush(_coverage_fout);
  }
  if ((double )__x == 0.0) {
    {
    fprintf(_coverage_fout, "173\n");
    fflush(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    fprintf(_coverage_fout, "176\n");
    fflush(_coverage_fout);
    }
    if ((double )__x > 0.0) {
      {
      fprintf(_coverage_fout, "174\n");
      fflush(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      fprintf(_coverage_fout, "175\n");
      fflush(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    fprintf(_coverage_fout, "177\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  fprintf(_coverage_fout, "179\n");
  fflush(_coverage_fout);
  }
  return ((float )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) float __sgnf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) double __sgn(double __x ) ;
__inline extern double __sgn(double __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "171\n");
  fflush(_coverage_fout);
  }
  if (__x == 0.0) {
    {
    fprintf(_coverage_fout, "166\n");
    fflush(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    fprintf(_coverage_fout, "169\n");
    fflush(_coverage_fout);
    }
    if (__x > 0.0) {
      {
      fprintf(_coverage_fout, "167\n");
      fflush(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      fprintf(_coverage_fout, "168\n");
      fflush(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    fprintf(_coverage_fout, "170\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  fprintf(_coverage_fout, "172\n");
  fflush(_coverage_fout);
  }
  return (tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) double __sgn(double __x ) ;
union __anonunion___u_26 {
   long double __l ;
   int __i[3] ;
};
__inline extern  __attribute__((__nothrow__)) int __signbitl(long double __x )  __attribute__((__const__)) ;
__inline extern int __signbitl(long double __x ) 
{ union __anonunion___u_26 __u ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "164\n");
  fflush(_coverage_fout);
  }
  __u.__l = __x;
  {
  fprintf(_coverage_fout, "165\n");
  fflush(_coverage_fout);
  }
  return ((__u.__i[2] & 0x8000) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbitl(long double __x )  __attribute__((__const__)) ;
union __anonunion___u_25 {
   double __d ;
   int __i[2] ;
};
__inline extern  __attribute__((__nothrow__)) int __signbit(double __x )  __attribute__((__const__)) ;
__inline extern int __signbit(double __x ) 
{ union __anonunion___u_25 __u ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "162\n");
  fflush(_coverage_fout);
  }
  __u.__d = __x;
  {
  fprintf(_coverage_fout, "163\n");
  fflush(_coverage_fout);
  }
  return (__u.__i[1] < 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbit(double __x )  __attribute__((__const__)) ;
union __anonunion___u_24 {
   float __f ;
   int __i ;
};
__inline extern  __attribute__((__nothrow__)) int __signbitf(float __x )  __attribute__((__const__)) ;
__inline extern int __signbitf(float __x ) 
{ union __anonunion___u_24 __u ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "160\n");
  fflush(_coverage_fout);
  }
  __u.__f = __x;
  {
  fprintf(_coverage_fout, "161\n");
  fflush(_coverage_fout);
  }
  return (__u.__i < 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbitf(float __x )  __attribute__((__const__)) ;
struct exception;
extern int matherr(struct exception *__exc ) ;
enum __anonenum__LIB_VERSION_TYPE_23;
typedef enum __anonenum__LIB_VERSION_TYPE_23 _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION ;
extern int signgam ;
extern  __attribute__((__nothrow__)) long double __scalbl(long double __x ,
                                                          long double __n ) ;
extern  __attribute__((__nothrow__)) long double scalbl(long double __x ,
                                                        long double __n ) ;
extern  __attribute__((__nothrow__)) long double __fmal(long double __x ,
                                                        long double __y ,
                                                        long double __z ) ;
extern  __attribute__((__nothrow__)) long double fmal(long double __x ,
                                                      long double __y ,
                                                      long double __z ) ;
extern  __attribute__((__nothrow__)) int __fpclassifyl(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __fminl(long double __x ,
                                                         long double __y ) ;
extern  __attribute__((__nothrow__)) long double fminl(long double __x ,
                                                       long double __y ) ;
extern  __attribute__((__nothrow__)) long double __fmaxl(long double __x ,
                                                         long double __y ) ;
extern  __attribute__((__nothrow__)) long double fmaxl(long double __x ,
                                                       long double __y ) ;
extern  __attribute__((__nothrow__)) long double __fdiml(long double __x ,
                                                         long double __y ) ;
extern  __attribute__((__nothrow__)) long double fdiml(long double __x ,
                                                       long double __y ) ;
extern  __attribute__((__nothrow__)) long long __llroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long long llroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long __lroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long lroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long long __llrintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long __lrintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __remquol(long double __x ,
                                                           long double __y ,
                                                           int *__quo ) ;
extern  __attribute__((__nothrow__)) long double remquol(long double __x ,
                                                         long double __y ,
                                                         int *__quo ) ;
extern  __attribute__((__nothrow__)) long double __truncl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double truncl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __roundl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double roundl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __nearbyintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double nearbyintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __scalblnl(long double __x ,
                                                            long __n ) ;
extern  __attribute__((__nothrow__)) long double scalblnl(long double __x ,
                                                          long __n ) ;
extern  __attribute__((__nothrow__)) int __ilogbl(long double __x ) ;
extern  __attribute__((__nothrow__)) int ilogbl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __scalbnl(long double __x ,
                                                           int __n ) ;
extern  __attribute__((__nothrow__)) long double scalbnl(long double __x ,
                                                         int __n ) ;
extern  __attribute__((__nothrow__)) long double __remainderl(long double __x ,
                                                              long double __y ) ;
extern  __attribute__((__nothrow__)) long double remainderl(long double __x ,
                                                            long double __y ) ;
extern  __attribute__((__nothrow__)) long double __nexttowardl(long double __x ,
                                                               long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double nexttowardl(long double __x ,
                                                             long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __nextafterl(long double __x ,
                                                              long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double nextafterl(long double __x ,
                                                            long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __rintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double rintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __lgammal_r(long double  ,
                                                             int *__signgamp ) ;
extern  __attribute__((__nothrow__)) long double lgammal_r(long double  ,
                                                           int *__signgamp ) ;
extern  __attribute__((__nothrow__)) long double __gammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double gammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double __tgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double tgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double __lgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double lgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double __erfcl(long double  ) ;
extern  __attribute__((__nothrow__)) long double erfcl(long double  ) ;
extern  __attribute__((__nothrow__)) long double __erfl(long double  ) ;
extern  __attribute__((__nothrow__)) long double erfl(long double  ) ;
extern  __attribute__((__nothrow__)) long double __ynl(int  , long double  ) ;
extern  __attribute__((__nothrow__)) long double ynl(int  , long double  ) ;
extern  __attribute__((__nothrow__)) long double __y1l(long double  ) ;
extern  __attribute__((__nothrow__)) long double y1l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __y0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double y0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __jnl(int  , long double  ) ;
extern  __attribute__((__nothrow__)) long double jnl(int  , long double  ) ;
extern  __attribute__((__nothrow__)) long double __j1l(long double  ) ;
extern  __attribute__((__nothrow__)) long double j1l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __j0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double j0l(long double  ) ;
extern  __attribute__((__nothrow__)) int isnanl(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isnanl(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __nanl(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double nanl(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __copysignl(long double __x ,
                                                             long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double copysignl(long double __x ,
                                                           long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __significandl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double significandl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __dreml(long double __x ,
                                                         long double __y ) ;
extern  __attribute__((__nothrow__)) long double dreml(long double __x ,
                                                       long double __y ) ;
extern  __attribute__((__nothrow__)) int finitel(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isinfl(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __finitel(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isinfl(long double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __fmodl(long double __x ,
                                                         long double __y ) ;
extern  __attribute__((__nothrow__)) long double fmodl(long double __x ,
                                                       long double __y ) ;
extern  __attribute__((__nothrow__)) long double __floorl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __ceill(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __cbrtl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double cbrtl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __hypotl(long double __x ,
                                                          long double __y ) ;
extern  __attribute__((__nothrow__)) long double hypotl(long double __x ,
                                                        long double __y ) ;
extern  __attribute__((__nothrow__)) long double __sqrtl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double sqrtl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __powl(long double __x ,
                                                        long double __y ) ;
extern  __attribute__((__nothrow__)) long double powl(long double __x ,
                                                      long double __y ) ;
extern  __attribute__((__nothrow__)) long double __log2l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double log2l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __exp2l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double exp2l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __logbl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double logbl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __log1pl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double log1pl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __expm1l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double expm1l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __pow10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double pow10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __exp10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double exp10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __modfl(long double __x ,
                                                         long double *__iptr ) ;
extern  __attribute__((__nothrow__)) long double modfl(long double __x ,
                                                       long double *__iptr ) ;
extern  __attribute__((__nothrow__)) long double __log10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double log10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __logl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double logl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __ldexpl(long double __x ,
                                                          int __exponent ) ;
extern  __attribute__((__nothrow__)) long double ldexpl(long double __x ,
                                                        int __exponent ) ;
extern  __attribute__((__nothrow__)) long double __frexpl(long double __x ,
                                                          int *__exponent ) ;
extern  __attribute__((__nothrow__)) long double frexpl(long double __x ,
                                                        int *__exponent ) ;
extern  __attribute__((__nothrow__)) long double __expl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double expl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __atanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double atanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __asinhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double asinhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __acoshl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double acoshl(long double __x ) ;
extern  __attribute__((__nothrow__)) void __sincosl(long double __x ,
                                                    long double *__sinx ,
                                                    long double *__cosx ) ;
extern  __attribute__((__nothrow__)) void sincosl(long double __x ,
                                                  long double *__sinx ,
                                                  long double *__cosx ) ;
extern  __attribute__((__nothrow__)) long double __tanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double tanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __sinhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double sinhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __coshl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double coshl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __tanl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double tanl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __sinl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double sinl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __cosl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double cosl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double atan2l(long double __y ,
                                                        long double __x ) ;
extern  __attribute__((__nothrow__)) long double __atanl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double atanl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __asinl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double asinl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __acosl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double acosl(long double __x ) ;
extern  __attribute__((__nothrow__)) float __scalbf(float __x , float __n ) ;
extern  __attribute__((__nothrow__)) float scalbf(float __x , float __n ) ;
extern  __attribute__((__nothrow__)) float __fmaf(float __x , float __y ,
                                                  float __z ) ;
extern  __attribute__((__nothrow__)) float fmaf(float __x , float __y ,
                                                float __z ) ;
extern  __attribute__((__nothrow__)) int __fpclassifyf(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __fminf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float fminf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __fmaxf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float fmaxf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __fdimf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float fdimf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) long long __llroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long long llroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long __lroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long lroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long long __llrintf(float __x ) ;
extern  __attribute__((__nothrow__)) long __lrintf(float __x ) ;
extern  __attribute__((__nothrow__)) float __remquof(float __x , float __y ,
                                                     int *__quo ) ;
extern  __attribute__((__nothrow__)) float remquof(float __x , float __y ,
                                                   int *__quo ) ;
extern  __attribute__((__nothrow__)) float __truncf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float truncf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __roundf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float roundf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __nearbyintf(float __x ) ;
extern  __attribute__((__nothrow__)) float nearbyintf(float __x ) ;
extern  __attribute__((__nothrow__)) float __scalblnf(float __x , long __n ) ;
extern  __attribute__((__nothrow__)) float scalblnf(float __x , long __n ) ;
extern  __attribute__((__nothrow__)) int __ilogbf(float __x ) ;
extern  __attribute__((__nothrow__)) int ilogbf(float __x ) ;
extern  __attribute__((__nothrow__)) float __scalbnf(float __x , int __n ) ;
extern  __attribute__((__nothrow__)) float scalbnf(float __x , int __n ) ;
extern  __attribute__((__nothrow__)) float __remainderf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float remainderf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __nexttowardf(float __x ,
                                                         long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float nexttowardf(float __x ,
                                                       long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __nextafterf(float __x , float __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float nextafterf(float __x , float __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __rintf(float __x ) ;
extern  __attribute__((__nothrow__)) float rintf(float __x ) ;
extern  __attribute__((__nothrow__)) float __lgammaf_r(float  , int *__signgamp ) ;
extern  __attribute__((__nothrow__)) float lgammaf_r(float  , int *__signgamp ) ;
extern  __attribute__((__nothrow__)) float __gammaf(float  ) ;
extern  __attribute__((__nothrow__)) float gammaf(float  ) ;
extern  __attribute__((__nothrow__)) float __tgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float tgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float __lgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float lgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float __erfcf(float  ) ;
extern  __attribute__((__nothrow__)) float erfcf(float  ) ;
extern  __attribute__((__nothrow__)) float __erff(float  ) ;
extern  __attribute__((__nothrow__)) float erff(float  ) ;
extern  __attribute__((__nothrow__)) float __ynf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float ynf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float __y1f(float  ) ;
extern  __attribute__((__nothrow__)) float y1f(float  ) ;
extern  __attribute__((__nothrow__)) float __y0f(float  ) ;
extern  __attribute__((__nothrow__)) float y0f(float  ) ;
extern  __attribute__((__nothrow__)) float __jnf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float jnf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float __j1f(float  ) ;
extern  __attribute__((__nothrow__)) float j1f(float  ) ;
extern  __attribute__((__nothrow__)) float __j0f(float  ) ;
extern  __attribute__((__nothrow__)) float j0f(float  ) ;
extern  __attribute__((__nothrow__)) int isnanf(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isnanf(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __nanf(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float nanf(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __copysignf(float __x , float __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float copysignf(float __x , float __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __significandf(float __x ) ;
extern  __attribute__((__nothrow__)) float significandf(float __x ) ;
extern  __attribute__((__nothrow__)) float __dremf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float dremf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) int finitef(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isinff(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __finitef(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isinff(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __fmodf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float fmodf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __floorf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __fabsf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __ceilf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __cbrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float cbrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float __hypotf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float hypotf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __sqrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float sqrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float __powf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float powf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __log2f(float __x ) ;
extern  __attribute__((__nothrow__)) float log2f(float __x ) ;
extern  __attribute__((__nothrow__)) float __exp2f(float __x ) ;
extern  __attribute__((__nothrow__)) float exp2f(float __x ) ;
extern  __attribute__((__nothrow__)) float __logbf(float __x ) ;
extern  __attribute__((__nothrow__)) float logbf(float __x ) ;
extern  __attribute__((__nothrow__)) float __log1pf(float __x ) ;
extern  __attribute__((__nothrow__)) float log1pf(float __x ) ;
extern  __attribute__((__nothrow__)) float __expm1f(float __x ) ;
extern  __attribute__((__nothrow__)) float expm1f(float __x ) ;
extern  __attribute__((__nothrow__)) float __pow10f(float __x ) ;
extern  __attribute__((__nothrow__)) float pow10f(float __x ) ;
extern  __attribute__((__nothrow__)) float __exp10f(float __x ) ;
extern  __attribute__((__nothrow__)) float exp10f(float __x ) ;
extern  __attribute__((__nothrow__)) float __modff(float __x , float *__iptr ) ;
extern  __attribute__((__nothrow__)) float modff(float __x , float *__iptr ) ;
extern  __attribute__((__nothrow__)) float __log10f(float __x ) ;
extern  __attribute__((__nothrow__)) float log10f(float __x ) ;
extern  __attribute__((__nothrow__)) float __logf(float __x ) ;
extern  __attribute__((__nothrow__)) float logf(float __x ) ;
extern  __attribute__((__nothrow__)) float __ldexpf(float __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) float ldexpf(float __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) float __frexpf(float __x , int *__exponent ) ;
extern  __attribute__((__nothrow__)) float frexpf(float __x , int *__exponent ) ;
extern  __attribute__((__nothrow__)) float __expf(float __x ) ;
extern  __attribute__((__nothrow__)) float expf(float __x ) ;
extern  __attribute__((__nothrow__)) float __atanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float atanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __asinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float asinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __acoshf(float __x ) ;
extern  __attribute__((__nothrow__)) float acoshf(float __x ) ;
extern  __attribute__((__nothrow__)) void __sincosf(float __x , float *__sinx ,
                                                    float *__cosx ) ;
extern  __attribute__((__nothrow__)) void sincosf(float __x , float *__sinx ,
                                                  float *__cosx ) ;
extern  __attribute__((__nothrow__)) float __tanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float tanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __sinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float sinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __coshf(float __x ) ;
extern  __attribute__((__nothrow__)) float coshf(float __x ) ;
extern  __attribute__((__nothrow__)) float __tanf(float __x ) ;
extern  __attribute__((__nothrow__)) float tanf(float __x ) ;
extern  __attribute__((__nothrow__)) float __sinf(float __x ) ;
extern  __attribute__((__nothrow__)) float sinf(float __x ) ;
extern  __attribute__((__nothrow__)) float __cosf(float __x ) ;
extern  __attribute__((__nothrow__)) float cosf(float __x ) ;
extern  __attribute__((__nothrow__)) float __atan2f(float __y , float __x ) ;
extern  __attribute__((__nothrow__)) float atan2f(float __y , float __x ) ;
extern  __attribute__((__nothrow__)) float __atanf(float __x ) ;
extern  __attribute__((__nothrow__)) float atanf(float __x ) ;
extern  __attribute__((__nothrow__)) float __asinf(float __x ) ;
extern  __attribute__((__nothrow__)) float asinf(float __x ) ;
extern  __attribute__((__nothrow__)) float __acosf(float __x ) ;
extern  __attribute__((__nothrow__)) float acosf(float __x ) ;
extern  __attribute__((__nothrow__)) double __scalb(double __x , double __n ) ;
extern  __attribute__((__nothrow__)) double scalb(double __x , double __n ) ;
extern  __attribute__((__nothrow__)) double __fma(double __x , double __y ,
                                                  double __z ) ;
extern  __attribute__((__nothrow__)) double fma(double __x , double __y ,
                                                double __z ) ;
extern  __attribute__((__nothrow__)) int __fpclassify(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __fmin(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double fmin(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __fmax(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double fmax(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __fdim(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double fdim(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) long long __llround(double __x ) ;
extern  __attribute__((__nothrow__)) long long llround(double __x ) ;
extern  __attribute__((__nothrow__)) long __lround(double __x ) ;
extern  __attribute__((__nothrow__)) long lround(double __x ) ;
extern  __attribute__((__nothrow__)) long long __llrint(double __x ) ;
extern  __attribute__((__nothrow__)) long __lrint(double __x ) ;
extern  __attribute__((__nothrow__)) double __remquo(double __x , double __y ,
                                                     int *__quo ) ;
extern  __attribute__((__nothrow__)) double remquo(double __x , double __y ,
                                                   int *__quo ) ;
extern  __attribute__((__nothrow__)) double __trunc(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double trunc(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __round(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double round(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __nearbyint(double __x ) ;
extern  __attribute__((__nothrow__)) double nearbyint(double __x ) ;
extern  __attribute__((__nothrow__)) double __scalbln(double __x , long __n ) ;
extern  __attribute__((__nothrow__)) double scalbln(double __x , long __n ) ;
extern  __attribute__((__nothrow__)) int __ilogb(double __x ) ;
extern  __attribute__((__nothrow__)) int ilogb(double __x ) ;
extern  __attribute__((__nothrow__)) double __scalbn(double __x , int __n ) ;
extern  __attribute__((__nothrow__)) double scalbn(double __x , int __n ) ;
extern  __attribute__((__nothrow__)) double __remainder(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double remainder(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __nexttoward(double __x ,
                                                         long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double nexttoward(double __x ,
                                                       long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __nextafter(double __x , double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double nextafter(double __x , double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __rint(double __x ) ;
extern  __attribute__((__nothrow__)) double rint(double __x ) ;
extern  __attribute__((__nothrow__)) double __lgamma_r(double  ,
                                                       int *__signgamp ) ;
extern  __attribute__((__nothrow__)) double lgamma_r(double  , int *__signgamp ) ;
extern  __attribute__((__nothrow__)) double __gamma(double  ) ;
extern  __attribute__((__nothrow__)) double gamma(double  ) ;
extern  __attribute__((__nothrow__)) double __tgamma(double  ) ;
extern  __attribute__((__nothrow__)) double tgamma(double  ) ;
extern  __attribute__((__nothrow__)) double __lgamma(double  ) ;
extern  __attribute__((__nothrow__)) double lgamma(double  ) ;
extern  __attribute__((__nothrow__)) double __erfc(double  ) ;
extern  __attribute__((__nothrow__)) double erfc(double  ) ;
extern  __attribute__((__nothrow__)) double __erf(double  ) ;
extern  __attribute__((__nothrow__)) double erf(double  ) ;
extern  __attribute__((__nothrow__)) double __yn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double yn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double __y1(double  ) ;
extern  __attribute__((__nothrow__)) double y1(double  ) ;
extern  __attribute__((__nothrow__)) double __y0(double  ) ;
extern  __attribute__((__nothrow__)) double y0(double  ) ;
extern  __attribute__((__nothrow__)) double __jn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double jn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double __j1(double  ) ;
extern  __attribute__((__nothrow__)) double j1(double  ) ;
extern  __attribute__((__nothrow__)) double __j0(double  ) ;
extern  __attribute__((__nothrow__)) double j0(double  ) ;
extern  __attribute__((__nothrow__)) int isnan(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isnan(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __nan(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double nan(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __copysign(double __x , double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double copysign(double __x , double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __significand(double __x ) ;
extern  __attribute__((__nothrow__)) double significand(double __x ) ;
extern  __attribute__((__nothrow__)) double __drem(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double drem(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) int finite(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isinf(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isinf(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __fmod(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double fmod(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __floor(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __fabs(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __ceil(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __cbrt(double __x ) ;
extern  __attribute__((__nothrow__)) double cbrt(double __x ) ;
extern  __attribute__((__nothrow__)) double __hypot(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double hypot(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __sqrt(double __x ) ;
extern  __attribute__((__nothrow__)) double sqrt(double __x ) ;
extern  __attribute__((__nothrow__)) double __pow(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double pow(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __log2(double __x ) ;
extern  __attribute__((__nothrow__)) double log2(double __x ) ;
extern  __attribute__((__nothrow__)) double __exp2(double __x ) ;
extern  __attribute__((__nothrow__)) double exp2(double __x ) ;
extern  __attribute__((__nothrow__)) double __logb(double __x ) ;
extern  __attribute__((__nothrow__)) double logb(double __x ) ;
extern  __attribute__((__nothrow__)) double __log1p(double __x ) ;
extern  __attribute__((__nothrow__)) double log1p(double __x ) ;
extern  __attribute__((__nothrow__)) double __expm1(double __x ) ;
extern  __attribute__((__nothrow__)) double expm1(double __x ) ;
extern  __attribute__((__nothrow__)) double __pow10(double __x ) ;
extern  __attribute__((__nothrow__)) double pow10(double __x ) ;
extern  __attribute__((__nothrow__)) double __exp10(double __x ) ;
extern  __attribute__((__nothrow__)) double exp10(double __x ) ;
extern  __attribute__((__nothrow__)) double __modf(double __x , double *__iptr ) ;
extern  __attribute__((__nothrow__)) double modf(double __x , double *__iptr ) ;
extern  __attribute__((__nothrow__)) double __log10(double __x ) ;
extern  __attribute__((__nothrow__)) double log10(double __x ) ;
extern  __attribute__((__nothrow__)) double __log(double __x ) ;
extern  __attribute__((__nothrow__)) double log(double __x ) ;
extern  __attribute__((__nothrow__)) double __ldexp(double __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) double ldexp(double __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) double __frexp(double __x ,
                                                    int *__exponent ) ;
extern  __attribute__((__nothrow__)) double frexp(double __x , int *__exponent ) ;
extern  __attribute__((__nothrow__)) double __exp(double __x ) ;
extern  __attribute__((__nothrow__)) double exp(double __x ) ;
extern  __attribute__((__nothrow__)) double __atanh(double __x ) ;
extern  __attribute__((__nothrow__)) double atanh(double __x ) ;
extern  __attribute__((__nothrow__)) double __asinh(double __x ) ;
extern  __attribute__((__nothrow__)) double asinh(double __x ) ;
extern  __attribute__((__nothrow__)) double __acosh(double __x ) ;
extern  __attribute__((__nothrow__)) double acosh(double __x ) ;
extern  __attribute__((__nothrow__)) void __sincos(double __x , double *__sinx ,
                                                   double *__cosx ) ;
extern  __attribute__((__nothrow__)) void sincos(double __x , double *__sinx ,
                                                 double *__cosx ) ;
extern  __attribute__((__nothrow__)) double __tanh(double __x ) ;
extern  __attribute__((__nothrow__)) double tanh(double __x ) ;
extern  __attribute__((__nothrow__)) double __sinh(double __x ) ;
extern  __attribute__((__nothrow__)) double sinh(double __x ) ;
extern  __attribute__((__nothrow__)) double __cosh(double __x ) ;
extern  __attribute__((__nothrow__)) double cosh(double __x ) ;
extern  __attribute__((__nothrow__)) double __tan(double __x ) ;
extern  __attribute__((__nothrow__)) double tan(double __x ) ;
extern  __attribute__((__nothrow__)) double __sin(double __x ) ;
extern  __attribute__((__nothrow__)) double sin(double __x ) ;
extern  __attribute__((__nothrow__)) double __cos(double __x ) ;
extern  __attribute__((__nothrow__)) double cos(double __x ) ;
extern  __attribute__((__nothrow__)) double __atan2(double __y , double __x ) ;
extern  __attribute__((__nothrow__)) double atan2(double __y , double __x ) ;
extern  __attribute__((__nothrow__)) double __atan(double __x ) ;
extern  __attribute__((__nothrow__)) double atan(double __x ) ;
extern  __attribute__((__nothrow__)) double __asin(double __x ) ;
extern  __attribute__((__nothrow__)) double asin(double __x ) ;
extern  __attribute__((__nothrow__)) double __acos(double __x ) ;
extern  __attribute__((__nothrow__)) double acos(double __x ) ;
extern  __attribute__((__nothrow__)) char *__strndup(char const   *__string ,
                                                     size_t __n )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) char *__strdup(char const   *__string )  __attribute__((__malloc__)) ;
__inline extern char *__strsep_3c(char **__s , char __reject1 , char __reject2 ,
                                  char __reject3 ) 
{ register char *__retval ;
  register char *__cp ;
  char *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "157\n");
  fflush(_coverage_fout);
  }
  __retval = *__s;
  {
  fprintf(_coverage_fout, "158\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "153\n");
    fflush(_coverage_fout);
    }
    __cp = __retval;
    {
    fprintf(_coverage_fout, "154\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "150\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        fprintf(_coverage_fout, "136\n");
        fflush(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        fprintf(_coverage_fout, "137\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "151\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        fprintf(_coverage_fout, "138\n");
        fflush(_coverage_fout);
        }
        tmp = __cp;
        {
        fprintf(_coverage_fout, "139\n");
        fflush(_coverage_fout);
        }
        __cp ++;
        {
        fprintf(_coverage_fout, "140\n");
        fflush(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        fprintf(_coverage_fout, "149\n");
        fflush(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          fprintf(_coverage_fout, "141\n");
          fflush(_coverage_fout);
          }
          tmp = __cp;
          {
          fprintf(_coverage_fout, "142\n");
          fflush(_coverage_fout);
          }
          __cp ++;
          {
          fprintf(_coverage_fout, "143\n");
          fflush(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          fprintf(_coverage_fout, "148\n");
          fflush(_coverage_fout);
          }
          if ((int )*__cp == (int )__reject3) {
            {
            fprintf(_coverage_fout, "144\n");
            fflush(_coverage_fout);
            }
            tmp = __cp;
            {
            fprintf(_coverage_fout, "145\n");
            fflush(_coverage_fout);
            }
            __cp ++;
            {
            fprintf(_coverage_fout, "146\n");
            fflush(_coverage_fout);
            }
            *tmp = (char )'\000';
            break;
          } else {
            {
            fprintf(_coverage_fout, "147\n");
            fflush(_coverage_fout);
            }

          }
        }
      }
      {
      fprintf(_coverage_fout, "152\n");
      fflush(_coverage_fout);
      }
      __cp ++;
    }
    {
    fprintf(_coverage_fout, "155\n");
    fflush(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    fprintf(_coverage_fout, "156\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "159\n");
  fflush(_coverage_fout);
  }
  return (__retval);
}
}
__inline extern char *__strsep_3c(char **__s , char __reject1 , char __reject2 ,
                                  char __reject3 ) ;
__inline extern char *__strsep_2c(char **__s , char __reject1 , char __reject2 ) 
{ register char *__retval ;
  register char *__cp ;
  char *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "133\n");
  fflush(_coverage_fout);
  }
  __retval = *__s;
  {
  fprintf(_coverage_fout, "134\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "129\n");
    fflush(_coverage_fout);
    }
    __cp = __retval;
    {
    fprintf(_coverage_fout, "130\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "126\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        fprintf(_coverage_fout, "116\n");
        fflush(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        fprintf(_coverage_fout, "117\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "127\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        fprintf(_coverage_fout, "118\n");
        fflush(_coverage_fout);
        }
        tmp = __cp;
        {
        fprintf(_coverage_fout, "119\n");
        fflush(_coverage_fout);
        }
        __cp ++;
        {
        fprintf(_coverage_fout, "120\n");
        fflush(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        fprintf(_coverage_fout, "125\n");
        fflush(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          fprintf(_coverage_fout, "121\n");
          fflush(_coverage_fout);
          }
          tmp = __cp;
          {
          fprintf(_coverage_fout, "122\n");
          fflush(_coverage_fout);
          }
          __cp ++;
          {
          fprintf(_coverage_fout, "123\n");
          fflush(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          fprintf(_coverage_fout, "124\n");
          fflush(_coverage_fout);
          }

        }
      }
      {
      fprintf(_coverage_fout, "128\n");
      fflush(_coverage_fout);
      }
      __cp ++;
    }
    {
    fprintf(_coverage_fout, "131\n");
    fflush(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    fprintf(_coverage_fout, "132\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "135\n");
  fflush(_coverage_fout);
  }
  return (__retval);
}
}
__inline extern char *__strsep_2c(char **__s , char __reject1 , char __reject2 ) ;
__inline extern char *__strsep_1c(char **__s , char __reject ) 
{ register char *__retval ;
  char *tmp ;
  char *tmp___0 ;
  void *tmp___1 ;
  char *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "113\n");
  fflush(_coverage_fout);
  }
  __retval = *__s;
  {
  fprintf(_coverage_fout, "114\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "108\n");
    fflush(_coverage_fout);
    }
    tmp___2 = __builtin_strchr(__retval, (int )__reject);
    {
    fprintf(_coverage_fout, "109\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp___2;
    {
    fprintf(_coverage_fout, "110\n");
    fflush(_coverage_fout);
    }
    *__s = tmp___0;
    {
    fprintf(_coverage_fout, "111\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )tmp___0 != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "104\n");
      fflush(_coverage_fout);
      }
      tmp = *__s;
      {
      fprintf(_coverage_fout, "105\n");
      fflush(_coverage_fout);
      }
      (*__s) ++;
      {
      fprintf(_coverage_fout, "106\n");
      fflush(_coverage_fout);
      }
      *tmp = (char )'\000';
    } else {
      {
      fprintf(_coverage_fout, "107\n");
      fflush(_coverage_fout);
      }

    }
  } else {
    {
    fprintf(_coverage_fout, "112\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "115\n");
  fflush(_coverage_fout);
  }
  return (__retval);
}
}
__inline extern char *__strsep_1c(char **__s , char __reject ) ;
extern char *__strsep_g(char **__stringp , char const   *__delim ) ;
__inline extern char *__strtok_r_1c(char *__s , char __sep , char **__nextp ) 
{ char *__result ;
  char *tmp ;
  char *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "98\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__s == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "81\n");
    fflush(_coverage_fout);
    }
    __s = *__nextp;
  } else {
    {
    fprintf(_coverage_fout, "82\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "99\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "84\n");
    fflush(_coverage_fout);
    }
    if ((int )*__s == (int )__sep) {
      {
      fprintf(_coverage_fout, "83\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "85\n");
    fflush(_coverage_fout);
    }
    __s ++;
  }
  {
  fprintf(_coverage_fout, "100\n");
  fflush(_coverage_fout);
  }
  __result = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "101\n");
  fflush(_coverage_fout);
  }
  if ((int )*__s != 0) {
    {
    fprintf(_coverage_fout, "93\n");
    fflush(_coverage_fout);
    }
    tmp = __s;
    {
    fprintf(_coverage_fout, "94\n");
    fflush(_coverage_fout);
    }
    __s ++;
    {
    fprintf(_coverage_fout, "95\n");
    fflush(_coverage_fout);
    }
    __result = tmp;
    {
    fprintf(_coverage_fout, "96\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "89\n");
      fflush(_coverage_fout);
      }
      if ((int )*__s != 0) {
        {
        fprintf(_coverage_fout, "86\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "90\n");
      fflush(_coverage_fout);
      }
      tmp___0 = __s;
      {
      fprintf(_coverage_fout, "91\n");
      fflush(_coverage_fout);
      }
      __s ++;
      {
      fprintf(_coverage_fout, "92\n");
      fflush(_coverage_fout);
      }
      if ((int )*tmp___0 == (int )__sep) {
        {
        fprintf(_coverage_fout, "87\n");
        fflush(_coverage_fout);
        }
        *(__s + -1) = (char )'\000';
        break;
      } else {
        {
        fprintf(_coverage_fout, "88\n");
        fflush(_coverage_fout);
        }

      }
    }
  } else {
    {
    fprintf(_coverage_fout, "97\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "102\n");
  fflush(_coverage_fout);
  }
  *__nextp = __s;
  {
  fprintf(_coverage_fout, "103\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern char *__strtok_r_1c(char *__s , char __sep , char **__nextp ) ;
__inline extern char *__strpbrk_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) 
{ char *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "78\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "74\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      fprintf(_coverage_fout, "73\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        fprintf(_coverage_fout, "72\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          fprintf(_coverage_fout, "71\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*__s != (int const   )__accept3) {
            {
            fprintf(_coverage_fout, "70\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "75\n");
    fflush(_coverage_fout);
    }
    __s ++;
  }
  {
  fprintf(_coverage_fout, "79\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    fprintf(_coverage_fout, "76\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    fprintf(_coverage_fout, "77\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  fprintf(_coverage_fout, "80\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern char *__strpbrk_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) ;
__inline extern char *__strpbrk_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) 
{ char *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "67\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "63\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      fprintf(_coverage_fout, "62\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        fprintf(_coverage_fout, "61\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          fprintf(_coverage_fout, "60\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "64\n");
    fflush(_coverage_fout);
    }
    __s ++;
  }
  {
  fprintf(_coverage_fout, "68\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    fprintf(_coverage_fout, "65\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    fprintf(_coverage_fout, "66\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  fprintf(_coverage_fout, "69\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern char *__strpbrk_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) ;
__inline extern size_t __strspn_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) 
{ register size_t __result ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "57\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "58\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "55\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      fprintf(_coverage_fout, "50\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "54\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) == (int const   )__accept2) {
        {
        fprintf(_coverage_fout, "51\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "53\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*(__s + __result) == (int const   )__accept3) {
          {
          fprintf(_coverage_fout, "52\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      }
    }
    {
    fprintf(_coverage_fout, "56\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "59\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strspn_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) ;
__inline extern size_t __strspn_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) 
{ register size_t __result ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "47\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "48\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "45\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      fprintf(_coverage_fout, "42\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "44\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) == (int const   )__accept2) {
        {
        fprintf(_coverage_fout, "43\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    fprintf(_coverage_fout, "46\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "49\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strspn_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) ;
__inline extern size_t __strspn_c1(char const   *__s , int __accept ) 
{ register size_t __result ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "39\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "40\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "37\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept) {
      {
      fprintf(_coverage_fout, "36\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "38\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "41\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strspn_c1(char const   *__s , int __accept ) ;
__inline extern size_t __strcspn_c3(char const   *__s , int __reject1 ,
                                    int __reject2 , int __reject3 ) 
{ register size_t __result ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "33\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "34\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "31\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      fprintf(_coverage_fout, "30\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        fprintf(_coverage_fout, "29\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          fprintf(_coverage_fout, "28\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*(__s + __result) != (int const   )__reject3) {
            {
            fprintf(_coverage_fout, "27\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "32\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "35\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strcspn_c3(char const   *__s , int __reject1 ,
                                    int __reject2 , int __reject3 ) ;
__inline extern size_t __strcspn_c2(char const   *__s , int __reject1 ,
                                    int __reject2 ) 
{ register size_t __result ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "24\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "25\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "22\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      fprintf(_coverage_fout, "21\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        fprintf(_coverage_fout, "20\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          fprintf(_coverage_fout, "19\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "23\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "26\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strcspn_c2(char const   *__s , int __reject1 ,
                                    int __reject2 ) ;
__inline extern size_t __strcspn_c1(char const   *__s , int __reject ) 
{ register size_t __result ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "16\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "17\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "14\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      fprintf(_coverage_fout, "13\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject) {
        {
        fprintf(_coverage_fout, "12\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "15\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "18\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strcspn_c1(char const   *__s , int __reject ) ;
extern void *__rawmemchr(void const   *__s , int __c ) ;
extern  __attribute__((__nothrow__)) char *basename(char const   *__filename )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *memfrob(void *__s , size_t __n )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strfry(char *__string )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int strverscmp(char const   *__s1 ,
                                                    char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *stpncpy(char * __restrict  __dest ,
                                                   char const   * __restrict  __src ,
                                                   size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *__stpncpy(char * __restrict  __dest ,
                                                     char const   * __restrict  __src ,
                                                     size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *stpcpy(char * __restrict  __dest ,
                                                  char const   * __restrict  __src )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *__stpcpy(char * __restrict  __dest ,
                                                    char const   * __restrict  __src )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strsignal(int __sig ) ;
extern  __attribute__((__nothrow__)) char *strsep(char ** __restrict  __stringp ,
                                                  char const   * __restrict  __delim )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int strncasecmp_l(char const   *__s1 ,
                                                       char const   *__s2 ,
                                                       size_t __n ,
                                                       __locale_t __loc )  __attribute__((__pure__,
__nonnull__(1,2,4))) ;
extern  __attribute__((__nothrow__)) int strcasecmp_l(char const   *__s1 ,
                                                      char const   *__s2 ,
                                                      __locale_t __loc )  __attribute__((__pure__,
__nonnull__(1,2,3))) ;
extern  __attribute__((__nothrow__)) int strcasecmp(char const   *__s1 ,
                                                    char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int ffsll(long long __ll )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int ffsl(long __l )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int ffs(int __i )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) char *rindex(char const   *__s , int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *index(char const   *__s , int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int bcmp(void const   *__s1 ,
                                              void const   *__s2 , size_t __n )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void bzero(void *__s , size_t __n )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void bcopy(void const   *__src ,
                                                void *__dest , size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void __bzero(void *__s , size_t __n )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strerror_l(int __errnum ,
                                                      __locale_t __l ) ;
extern  __attribute__((__nothrow__)) char *strerror_r(int __errnum ,
                                                      char *__buf ,
                                                      size_t __buflen )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *strerror(int __errnum ) ;
extern  __attribute__((__nothrow__)) size_t strnlen(char const   *__string ,
                                                    size_t __maxlen )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *mempcpy(void * __restrict  __dest ,
                                                   void const   * __restrict  __src ,
                                                   size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *__mempcpy(void * __restrict  __dest ,
                                                     void const   * __restrict  __src ,
                                                     size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *memmem(void const   *__haystack ,
                                                  size_t __haystacklen ,
                                                  void const   *__needle ,
                                                  size_t __needlelen )  __attribute__((__pure__,
__nonnull__(1,3))) ;
extern  __attribute__((__nothrow__)) char *strcasestr(char const   *__haystack ,
                                                      char const   *__needle )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strtok_r(char * __restrict  __s ,
                                                    char const   * __restrict  __delim ,
                                                    char ** __restrict  __save_ptr )  __attribute__((__nonnull__(2,3))) ;
extern  __attribute__((__nothrow__)) char *__strtok_r(char * __restrict  __s ,
                                                      char const   * __restrict  __delim ,
                                                      char ** __restrict  __save_ptr )  __attribute__((__nonnull__(2,3))) ;
extern  __attribute__((__nothrow__)) char *strtok(char * __restrict  __s ,
                                                  char const   * __restrict  __delim )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *strstr(char const   *__haystack ,
                                                  char const   *__needle )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strpbrk(char const   *__s ,
                                                   char const   *__accept )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) size_t strspn(char const   *__s ,
                                                   char const   *__accept )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) size_t strcspn(char const   *__s ,
                                                    char const   *__reject )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strchrnul(char const   *__s ,
                                                     int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strrchr(char const   *__s , int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strchr(char const   *__s , int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strndup(char const   *__string ,
                                                   size_t __n )  __attribute__((__nonnull__(1),
__malloc__)) ;
extern  __attribute__((__nothrow__)) char *strdup(char const   *__s )  __attribute__((__nonnull__(1),
__malloc__)) ;
extern  __attribute__((__nothrow__)) size_t strxfrm_l(char *__dest ,
                                                      char const   *__src ,
                                                      size_t __n ,
                                                      __locale_t __l )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) int strcoll_l(char const   *__s1 ,
                                                   char const   *__s2 ,
                                                   __locale_t __l )  __attribute__((__pure__,
__nonnull__(1,2,3))) ;
extern  __attribute__((__nothrow__)) size_t strxfrm(char * __restrict  __dest ,
                                                    char const   * __restrict  __src ,
                                                    size_t __n )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int strcoll(char const   *__s1 ,
                                                 char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int strncmp(char const   *__s1 ,
                                                 char const   *__s2 ,
                                                 size_t __n )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int strcmp(char const   *__s1 ,
                                                char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strncat(char * __restrict  __dest ,
                                                   char const   * __restrict  __src ,
                                                   size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strcat(char * __restrict  __dest ,
                                                  char const   * __restrict  __src )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strncpy(char * __restrict  __dest ,
                                                   char const   * __restrict  __src ,
                                                   size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strcpy(char * __restrict  __dest ,
                                                  char const   * __restrict  __src )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *memrchr(void const   *__s , int __c ,
                                                   size_t __n )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *rawmemchr(void const   *__s ,
                                                     int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *memccpy(void * __restrict  __dest ,
                                                   void const   * __restrict  __src ,
                                                   int __c , size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *memmove(void *__dest ,
                                                   void const   *__src ,
                                                   size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *memcpy(void * __restrict  __dest ,
                                                  void const   * __restrict  __src ,
                                                  size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int getloadavg(double *__loadavg ,
                                                    int __nelem )  __attribute__((__nonnull__(1))) ;
extern int getpt(void) ;
extern  __attribute__((__nothrow__)) int ptsname_r(int __fd , char *__buf ,
                                                   size_t __buflen )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *ptsname(int __fd ) ;
extern  __attribute__((__nothrow__)) int unlockpt(int __fd ) ;
extern  __attribute__((__nothrow__)) int grantpt(int __fd ) ;
extern int posix_openpt(int __oflag ) ;
extern  __attribute__((__nothrow__)) void setkey(char const   *__key )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int getsubopt(char ** __restrict  __optionp ,
                                                   char * const  * __restrict  __tokens ,
                                                   char ** __restrict  __valuep )  __attribute__((__nonnull__(1,2,3))) ;
extern  __attribute__((__nothrow__)) int rpmatch(char const   *__response )  __attribute__((__nonnull__(1))) ;
typedef long wchar_t;
extern  __attribute__((__nothrow__)) size_t wcstombs(char * __restrict  __s ,
                                                     wchar_t const   * __restrict  __pwcs ,
                                                     size_t __n ) ;
extern  __attribute__((__nothrow__)) size_t mbstowcs(wchar_t * __restrict  __pwcs ,
                                                     char const   * __restrict  __s ,
                                                     size_t __n ) ;
extern  __attribute__((__nothrow__)) int wctomb(char *__s , wchar_t __wchar ) ;
extern  __attribute__((__nothrow__)) int mbtowc(wchar_t * __restrict  __pwc ,
                                                char const   * __restrict  __s ,
                                                size_t __n ) ;
extern  __attribute__((__nothrow__)) int mblen(char const   *__s , size_t __n ) ;
extern  __attribute__((__nothrow__)) int qfcvt_r(long double __value ,
                                                 int __ndigit ,
                                                 int * __restrict  __decpt ,
                                                 int * __restrict  __sign ,
                                                 char * __restrict  __buf ,
                                                 size_t __len )  __attribute__((__nonnull__(3,4,5))) ;
extern  __attribute__((__nothrow__)) int qecvt_r(long double __value ,
                                                 int __ndigit ,
                                                 int * __restrict  __decpt ,
                                                 int * __restrict  __sign ,
                                                 char * __restrict  __buf ,
                                                 size_t __len )  __attribute__((__nonnull__(3,4,5))) ;
extern  __attribute__((__nothrow__)) int fcvt_r(double __value , int __ndigit ,
                                                int * __restrict  __decpt ,
                                                int * __restrict  __sign ,
                                                char * __restrict  __buf ,
                                                size_t __len )  __attribute__((__nonnull__(3,4,5))) ;
extern  __attribute__((__nothrow__)) int ecvt_r(double __value , int __ndigit ,
                                                int * __restrict  __decpt ,
                                                int * __restrict  __sign ,
                                                char * __restrict  __buf ,
                                                size_t __len )  __attribute__((__nonnull__(3,4,5))) ;
extern  __attribute__((__nothrow__)) char *qgcvt(long double __value ,
                                                 int __ndigit , char *__buf )  __attribute__((__nonnull__(3))) ;
extern  __attribute__((__nothrow__)) char *qfcvt(long double __value ,
                                                 int __ndigit ,
                                                 int * __restrict  __decpt ,
                                                 int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
extern  __attribute__((__nothrow__)) char *qecvt(long double __value ,
                                                 int __ndigit ,
                                                 int * __restrict  __decpt ,
                                                 int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
extern  __attribute__((__nothrow__)) char *gcvt(double __value , int __ndigit ,
                                                char *__buf )  __attribute__((__nonnull__(3))) ;
extern  __attribute__((__nothrow__)) char *fcvt(double __value , int __ndigit ,
                                                int * __restrict  __decpt ,
                                                int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
extern  __attribute__((__nothrow__)) char *ecvt(double __value , int __ndigit ,
                                                int * __restrict  __decpt ,
                                                int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
struct __anonstruct_lldiv_t_6;
typedef struct __anonstruct_lldiv_t_6 lldiv_t;
extern  __attribute__((__nothrow__)) lldiv_t lldiv(long long __numer ,
                                                   long long __denom )  __attribute__((__const__)) ;
struct __anonstruct_ldiv_t_5;
typedef struct __anonstruct_ldiv_t_5 ldiv_t;
extern  __attribute__((__nothrow__)) ldiv_t ldiv(long __numer , long __denom )  __attribute__((__const__)) ;
struct __anonstruct_div_t_4;
typedef struct __anonstruct_div_t_4 div_t;
extern  __attribute__((__nothrow__)) div_t div(int __numer , int __denom )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long long llabs(long long __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long labs(long __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int abs(int __x )  __attribute__((__const__)) ;
extern void qsort_r(void *__base , size_t __nmemb , size_t __size ,
                    int (*__compar)(void const   * , void const   * , void * ) ,
                    void *__arg )  __attribute__((__nonnull__(1,4))) ;
extern void qsort(void *__base , size_t __nmemb , size_t __size ,
                  int (*__compar)(void const   * , void const   * ) )  __attribute__((__nonnull__(1,4))) ;
extern void *bsearch(void const   *__key , void const   *__base ,
                     size_t __nmemb , size_t __size ,
                     int (*__compar)(void const   * , void const   * ) )  __attribute__((__nonnull__(1,2,5))) ;
extern  __attribute__((__nothrow__)) char *realpath(char const   * __restrict  __name ,
                                                    char * __restrict  __resolved ) ;
extern  __attribute__((__nothrow__)) char *canonicalize_file_name(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern int system(char const   *__command ) ;
extern int mkostemps64(char *__template , int __suffixlen , int __flags )  __attribute__((__nonnull__(1))) ;
extern int mkostemps(char *__template , int __suffixlen , int __flags )  __attribute__((__nonnull__(1))) ;
extern int mkostemp64(char *__template , int __flags )  __attribute__((__nonnull__(1))) ;
extern int mkostemp(char *__template , int __flags )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *mkdtemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern int mkstemps64(char *__template , int __suffixlen )  __attribute__((__nonnull__(1))) ;
extern int mkstemps(char *__template , int __suffixlen )  __attribute__((__nonnull__(1))) ;
extern int mkstemp64(char *__template )  __attribute__((__nonnull__(1))) ;
extern int mkstemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *mktemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int clearenv(void) ;
extern  __attribute__((__nothrow__)) int unsetenv(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int setenv(char const   *__name ,
                                                char const   *__value ,
                                                int __replace )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int putenv(char *__string )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *__secure_getenv(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *getenv(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__, __noreturn__)) void _Exit(int __status ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void quick_exit(int __status ) ;
extern  __attribute__((__nothrow__)) int on_exit(void (*__func)(int __status ,
                                                                void *__arg ) ,
                                                 void *__arg )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int at_quick_exit(void (*__func)(void) )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int atexit(void (*__func)(void) )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__, __noreturn__)) void abort(void) ;
extern  __attribute__((__nothrow__)) int posix_memalign(void **__memptr ,
                                                        size_t __alignment ,
                                                        size_t __size )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *valloc(size_t __size )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) void *alloca(size_t __size ) ;
extern  __attribute__((__nothrow__)) void cfree(void *__ptr ) ;
extern  __attribute__((__nothrow__)) void free(void *__ptr ) ;
extern  __attribute__((__nothrow__)) void *calloc(size_t __nmemb ,
                                                  size_t __size )  __attribute__((__malloc__)) ;
struct drand48_data;
extern  __attribute__((__nothrow__)) int lcong48_r(unsigned short *__param ,
                                                   struct drand48_data *__buffer )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int seed48_r(unsigned short *__seed16v ,
                                                  struct drand48_data *__buffer )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int srand48_r(long __seedval ,
                                                   struct drand48_data *__buffer )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int jrand48_r(unsigned short *__xsubi ,
                                                   struct drand48_data * __restrict  __buffer ,
                                                   long * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int mrand48_r(struct drand48_data * __restrict  __buffer ,
                                                   long * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int nrand48_r(unsigned short *__xsubi ,
                                                   struct drand48_data * __restrict  __buffer ,
                                                   long * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int lrand48_r(struct drand48_data * __restrict  __buffer ,
                                                   long * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int erand48_r(unsigned short *__xsubi ,
                                                   struct drand48_data * __restrict  __buffer ,
                                                   double * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int drand48_r(struct drand48_data * __restrict  __buffer ,
                                                   double * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void lcong48(unsigned short *__param )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) unsigned short *seed48(unsigned short *__seed16v )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void srand48(long __seedval ) ;
extern  __attribute__((__nothrow__)) long jrand48(unsigned short *__xsubi )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long mrand48(void) ;
extern  __attribute__((__nothrow__)) long nrand48(unsigned short *__xsubi )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long lrand48(void) ;
extern  __attribute__((__nothrow__)) double erand48(unsigned short *__xsubi )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) double drand48(void) ;
extern  __attribute__((__nothrow__)) int rand_r(unsigned int *__seed ) ;
extern  __attribute__((__nothrow__)) void srand(unsigned int __seed ) ;
extern  __attribute__((__nothrow__)) int rand(void) ;
struct random_data;
extern  __attribute__((__nothrow__)) int setstate_r(char * __restrict  __statebuf ,
                                                    struct random_data * __restrict  __buf )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int initstate_r(unsigned int __seed ,
                                                     char * __restrict  __statebuf ,
                                                     size_t __statelen ,
                                                     struct random_data * __restrict  __buf )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) int srandom_r(unsigned int __seed ,
                                                   struct random_data *__buf )  __attribute__((__nonnull__(2))) ;
typedef int int32_t;
extern  __attribute__((__nothrow__)) int random_r(struct random_data * __restrict  __buf ,
                                                  int32_t * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *setstate(char *__statebuf )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *initstate(unsigned int __seed ,
                                                     char *__statebuf ,
                                                     size_t __statelen )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) void srandom(unsigned int __seed ) ;
extern  __attribute__((__nothrow__)) long random(void) ;
__inline extern  __attribute__((__nothrow__)) unsigned long long gnu_dev_makedev(unsigned int __major ,
                                                                                 unsigned int __minor ) ;
__inline extern unsigned long long gnu_dev_makedev(unsigned int __major ,
                                                   unsigned int __minor ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11\n");
  fflush(_coverage_fout);
  }
  return (((unsigned long long )((__minor & 255U) | ((__major & 4095U) << 8)) | ((unsigned long long )(__minor & 4294967040U) << 12)) | ((unsigned long long )(__major & 4294963200U) << 32));
}
}
__inline extern  __attribute__((__nothrow__)) unsigned long long gnu_dev_makedev(unsigned int __major ,
                                                                                 unsigned int __minor ) ;
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_minor(unsigned long long __dev ) ;
__inline extern unsigned int gnu_dev_minor(unsigned long long __dev ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10\n");
  fflush(_coverage_fout);
  }
  return ((unsigned int )((__dev & 255ULL) | (unsigned long long )((unsigned int )(__dev >> 12) & 4294967040U)));
}
}
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_minor(unsigned long long __dev ) ;
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_major(unsigned long long __dev ) ;
__inline extern unsigned int gnu_dev_major(unsigned long long __dev ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "9\n");
  fflush(_coverage_fout);
  }
  return ((unsigned int )(((__dev >> 8) & 4095ULL) | (unsigned long long )((unsigned int )(__dev >> 32) & 4294963200U)));
}
}
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_major(unsigned long long __dev ) ;
struct __anonstruct___sigset_t_8;
struct __anonstruct_fd_set_9;
typedef struct __anonstruct_fd_set_9 fd_set;
extern int pselect(int __nfds , fd_set * __restrict  __readfds ,
                   fd_set * __restrict  __writefds ,
                   fd_set * __restrict  __exceptfds ,
                   struct timespec  const  * __restrict  __timeout ,
                   __sigset_t const   * __restrict  __sigmask ) ;
extern int select(int __nfds , fd_set * __restrict  __readfds ,
                  fd_set * __restrict  __writefds ,
                  fd_set * __restrict  __exceptfds ,
                  struct timeval * __restrict  __timeout ) ;
extern  __attribute__((__nothrow__)) long a64l(char const   *__s )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *l64a(long __n ) ;
extern  __attribute__((__nothrow__)) long long strtoll(char const   * __restrict  __nptr ,
                                                       char ** __restrict  __endptr ,
                                                       int __base )  __attribute__((__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) long long atoll(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern long long atoll(char const   *__nptr ) 
{ long long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "7\n");
  fflush(_coverage_fout);
  }
  tmp = strtoll((char const   */* __restrict  */)__nptr,
                (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  fprintf(_coverage_fout, "8\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long long atoll(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) long atol(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern long atol(char const   *__nptr ) 
{ long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "5\n");
  fflush(_coverage_fout);
  }
  tmp = strtol((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  fprintf(_coverage_fout, "6\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long atol(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) int atoi(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern int atoi(char const   *__nptr ) 
{ long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "3\n");
  fflush(_coverage_fout);
  }
  tmp = strtol((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  fprintf(_coverage_fout, "4\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int atoi(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) double strtod(char const   * __restrict  __nptr ,
                                                   char ** __restrict  __endptr )  __attribute__((__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) double atof(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern double atof(char const   *__nptr ) 
{ double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-01-18-95388b7cda-b9b1fb1827/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "1\n");
  fflush(_coverage_fout);
  }
  tmp = strtod((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)));
  {
  fprintf(_coverage_fout, "2\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) double atof(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long double strtold_l(char const   * __restrict  __nptr ,
                                                           char ** __restrict  __endptr ,
                                                           __locale_t __loc )  __attribute__((__nonnull__(1,3))) ;
extern  __attribute__((__nothrow__)) float strtof_l(char const   * __restrict  __nptr ,
                                                    char ** __restrict  __endptr ,
                                                    __locale_t __loc )  __attribute__((__nonnull__(1,3))) ;
extern  __attribute__((__nothrow__)) double strtod_l(char const   * __restrict  __nptr ,
                                                     char ** __restrict  __endptr ,
                                                     __locale_t __loc )  __attribute__((__nonnull__(1,3))) ;
extern  __attribute__((__nothrow__)) unsigned long long strtoull_l(char const   * __restrict  __nptr ,
                                                                   char ** __restrict  __endptr ,
                                                                   int __base ,
                                                                   __locale_t __loc )  __attribute__((__nonnull__(1,4))) ;
extern  __attribute__((__nothrow__)) long long strtoll_l(char const   * __restrict  __nptr ,
                                                         char ** __restrict  __endptr ,
                                                         int __base ,
                                                         __locale_t __loc )  __attribute__((__nonnull__(1,4))) ;
extern  __attribute__((__nothrow__)) unsigned long strtoul_l(char const   * __restrict  __nptr ,
                                                             char ** __restrict  __endptr ,
                                                             int __base ,
                                                             __locale_t __loc )  __attribute__((__nonnull__(1,4))) ;
extern  __attribute__((__nothrow__)) long strtol_l(char const   * __restrict  __nptr ,
                                                   char ** __restrict  __endptr ,
                                                   int __base ,
                                                   __locale_t __loc )  __attribute__((__nonnull__(1,4))) ;
extern  __attribute__((__nothrow__)) unsigned long long strtoull(char const   * __restrict  __nptr ,
                                                                 char ** __restrict  __endptr ,
                                                                 int __base )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) unsigned long long strtouq(char const   * __restrict  __nptr ,
                                                                char ** __restrict  __endptr ,
                                                                int __base )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long long strtoq(char const   * __restrict  __nptr ,
                                                      char ** __restrict  __endptr ,
                                                      int __base )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) unsigned long strtoul(char const   * __restrict  __nptr ,
                                                           char ** __restrict  __endptr ,
                                                           int __base )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long double strtold(char const   * __restrict  __nptr ,
                                                         char ** __restrict  __endptr )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) float strtof(char const   * __restrict  __nptr ,
                                                  char ** __restrict  __endptr )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) size_t __ctype_get_mb_cur_max(void) ;
struct _idsIterator {
   xmlChar *elementId ;
   xmlNode *element ;
};
struct _idsIterator;
typedef struct _idsIterator idsIterator;
enum __anonenum_xmlSchemaValidOption_112;
typedef enum __anonenum_xmlSchemaValidOption_112 xmlSchemaValidOption;
enum __anonenum_xmlSchemaValidOption_112 {
    XML_SCHEMA_VAL_VC_I_CREATE = 1
} ;
enum __anonenum_xmlSchemaValidError_111;
typedef enum __anonenum_xmlSchemaValidError_111 xmlSchemaValidError;
enum __anonenum_xmlSchemaValidError_111 {
    XML_SCHEMAS_ERR_OK = 0,
    XML_SCHEMAS_ERR_NOROOT = 1,
    XML_SCHEMAS_ERR_UNDECLAREDELEM = 2,
    XML_SCHEMAS_ERR_NOTTOPLEVEL = 3,
    XML_SCHEMAS_ERR_MISSING = 4,
    XML_SCHEMAS_ERR_WRONGELEM = 5,
    XML_SCHEMAS_ERR_NOTYPE = 6,
    XML_SCHEMAS_ERR_NOROLLBACK = 7,
    XML_SCHEMAS_ERR_ISABSTRACT = 8,
    XML_SCHEMAS_ERR_NOTEMPTY = 9,
    XML_SCHEMAS_ERR_ELEMCONT = 10,
    XML_SCHEMAS_ERR_HAVEDEFAULT = 11,
    XML_SCHEMAS_ERR_NOTNILLABLE = 12,
    XML_SCHEMAS_ERR_EXTRACONTENT = 13,
    XML_SCHEMAS_ERR_INVALIDATTR = 14,
    XML_SCHEMAS_ERR_INVALIDELEM = 15,
    XML_SCHEMAS_ERR_NOTDETERMINIST = 16,
    XML_SCHEMAS_ERR_CONSTRUCT = 17,
    XML_SCHEMAS_ERR_INTERNAL = 18,
    XML_SCHEMAS_ERR_NOTSIMPLE = 19,
    XML_SCHEMAS_ERR_ATTRUNKNOWN = 20,
    XML_SCHEMAS_ERR_ATTRINVALID = 21,
    XML_SCHEMAS_ERR_VALUE = 22,
    XML_SCHEMAS_ERR_FACET = 23,
    XML_SCHEMAS_ERR_ = 24,
    XML_SCHEMAS_ERR_XXX = 25
} ;
enum __anonenum_xmlRelaxNGParserFlag_110;
typedef enum __anonenum_xmlRelaxNGParserFlag_110 xmlRelaxNGParserFlag;
enum __anonenum_xmlRelaxNGParserFlag_110 {
    XML_RELAXNGP_NONE = 0,
    XML_RELAXNGP_FREE_DOC = 1,
    XML_RELAXNGP_CRNG = 2
} ;
enum __anonenum_xmlRelaxNGValidErr_109;
typedef enum __anonenum_xmlRelaxNGValidErr_109 xmlRelaxNGValidErr;
enum __anonenum_xmlRelaxNGValidErr_109 {
    XML_RELAXNG_OK = 0,
    XML_RELAXNG_ERR_MEMORY = 1,
    XML_RELAXNG_ERR_TYPE = 2,
    XML_RELAXNG_ERR_TYPEVAL = 3,
    XML_RELAXNG_ERR_DUPID = 4,
    XML_RELAXNG_ERR_TYPECMP = 5,
    XML_RELAXNG_ERR_NOSTATE = 6,
    XML_RELAXNG_ERR_NODEFINE = 7,
    XML_RELAXNG_ERR_LISTEXTRA = 8,
    XML_RELAXNG_ERR_LISTEMPTY = 9,
    XML_RELAXNG_ERR_INTERNODATA = 10,
    XML_RELAXNG_ERR_INTERSEQ = 11,
    XML_RELAXNG_ERR_INTEREXTRA = 12,
    XML_RELAXNG_ERR_ELEMNAME = 13,
    XML_RELAXNG_ERR_ATTRNAME = 14,
    XML_RELAXNG_ERR_ELEMNONS = 15,
    XML_RELAXNG_ERR_ATTRNONS = 16,
    XML_RELAXNG_ERR_ELEMWRONGNS = 17,
    XML_RELAXNG_ERR_ATTRWRONGNS = 18,
    XML_RELAXNG_ERR_ELEMEXTRANS = 19,
    XML_RELAXNG_ERR_ATTREXTRANS = 20,
    XML_RELAXNG_ERR_ELEMNOTEMPTY = 21,
    XML_RELAXNG_ERR_NOELEM = 22,
    XML_RELAXNG_ERR_NOTELEM = 23,
    XML_RELAXNG_ERR_ATTRVALID = 24,
    XML_RELAXNG_ERR_CONTENTVALID = 25,
    XML_RELAXNG_ERR_EXTRACONTENT = 26,
    XML_RELAXNG_ERR_INVALIDATTR = 27,
    XML_RELAXNG_ERR_DATAELEM = 28,
    XML_RELAXNG_ERR_VALELEM = 29,
    XML_RELAXNG_ERR_LISTELEM = 30,
    XML_RELAXNG_ERR_DATATYPE = 31,
    XML_RELAXNG_ERR_VALUE = 32,
    XML_RELAXNG_ERR_LIST = 33,
    XML_RELAXNG_ERR_NOGRAMMAR = 34,
    XML_RELAXNG_ERR_EXTRADATA = 35,
    XML_RELAXNG_ERR_LACKDATA = 36,
    XML_RELAXNG_ERR_INTERNAL = 37,
    XML_RELAXNG_ERR_ELEMWRONG = 38,
    XML_RELAXNG_ERR_TEXTWRONG = 39
} ;
enum __anonenum_dom_exception_code_108;
typedef enum __anonenum_dom_exception_code_108 dom_exception_code;
enum __anonenum_dom_exception_code_108 {
    PHP_ERR = 0,
    INDEX_SIZE_ERR = 1,
    DOMSTRING_SIZE_ERR = 2,
    HIERARCHY_REQUEST_ERR = 3,
    WRONG_DOCUMENT_ERR = 4,
    INVALID_CHARACTER_ERR = 5,
    NO_DATA_ALLOWED_ERR = 6,
    NO_MODIFICATION_ALLOWED_ERR = 7,
    NOT_FOUND_ERR = 8,
    NOT_SUPPORTED_ERR = 9,
    INUSE_ATTRIBUTE_ERR = 10,
    INVALID_STATE_ERR = 11,
    SYNTAX_ERR = 12,
    INVALID_MODIFICATION_ERR = 13,
    NAMESPACE_ERR = 14,
    INVALID_ACCESS_ERR = 15,
    VALIDATION_ERR = 16
} ;
struct __anonstruct_php_dom_iterator_107;
typedef struct __anonstruct_php_dom_iterator_107 php_dom_iterator;
struct _zend_object_iterator {
   void *data ;
   zend_object_iterator_funcs *funcs ;
   ulong index ;
};
struct __anonstruct_php_dom_iterator_107 {
   zend_object_iterator intern ;
   zval *curobj ;
};
struct _dom_nnodemap_object;
typedef struct _dom_nnodemap_object dom_nnodemap_object;
struct _dom_nnodemap_object {
   dom_object *baseobj ;
   int nodetype ;
   xmlHashTable *ht ;
   xmlChar *local ;
   xmlChar *ns ;
   zval *baseobjptr ;
};
struct _dom_xpath_object;
typedef struct _dom_xpath_object dom_xpath_object;
struct _dom_xpath_object {
   zend_object std ;
   void *ptr ;
   php_libxml_ref_obj *document ;
   HashTable *prop_handler ;
   zend_object_handle handle ;
   int registerPhpFunctions ;
   HashTable *registered_phpfunctions ;
   HashTable *node_list ;
};
typedef void *(*php_libxml_export_node)(zval *object );
struct _php_libxml_node_object {
   zend_object std ;
   php_libxml_node_ptr *node ;
   php_libxml_ref_obj *document ;
   HashTable *properties ;
};
struct _zend_libxml_globals;
typedef struct _zend_libxml_globals zend_libxml_globals;
struct __anonstruct_smart_str_106 {
   char *c ;
   size_t len ;
   size_t a ;
};
typedef struct __anonstruct_smart_str_106 smart_str;
struct _zend_libxml_globals {
   zval *stream_context ;
   smart_str error_buffer ;
   zend_llist *error_list ;
};
struct __anonstruct_smart_str_106;
struct _xmlLocationSet {
   int locNr ;
   int locMax ;
   xmlXPathObjectPtr *locTab ;
};
typedef int (*xmlC14NIsVisibleCallback)(void *user_data , xmlNodePtr node ,
                                        xmlNodePtr parent );
enum __anonenum_xmlC14NMode_105;
typedef enum __anonenum_xmlC14NMode_105 xmlC14NMode;
enum __anonenum_xmlC14NMode_105 {
    XML_C14N_1_0 = 0,
    XML_C14N_EXCLUSIVE_1_0 = 1,
    XML_C14N_1_1 = 2
} ;
struct _xmlXPathParserContext {
   xmlChar const   *cur ;
   xmlChar const   *base ;
   int error ;
   xmlXPathContextPtr context ;
   xmlXPathObjectPtr value ;
   int valueNr ;
   int valueMax ;
   xmlXPathObjectPtr *valueTab ;
   xmlXPathCompExprPtr comp ;
   int xptr ;
   xmlNodePtr ancestor ;
};
struct _xmlXPathAxis;
typedef struct _xmlXPathAxis xmlXPathAxis;
typedef xmlXPathAxis *xmlXPathAxisPtr;
struct _xmlXPathType;
typedef struct _xmlXPathType xmlXPathType;
typedef xmlXPathType *xmlXPathTypePtr;
struct _xmlXPathContext {
   xmlDocPtr doc ;
   xmlNodePtr node ;
   int nb_variables_unused ;
   int max_variables_unused ;
   xmlHashTablePtr varHash ;
   int nb_types ;
   int max_types ;
   xmlXPathTypePtr types ;
   int nb_funcs_unused ;
   int max_funcs_unused ;
   xmlHashTablePtr funcHash ;
   int nb_axis ;
   int max_axis ;
   xmlXPathAxisPtr axis ;
   xmlNsPtr *namespaces ;
   int nsNr ;
   void *user ;
   int contextSize ;
   int proximityPosition ;
   int xptr ;
   xmlNodePtr here ;
   xmlNodePtr origin ;
   xmlHashTablePtr nsHash ;
   xmlXPathObjectPtr (*varLookupFunc)(void *ctxt , xmlChar const   *name ,
                                      xmlChar const   *ns_uri ) ;
   void *varLookupData ;
   void *extra ;
   xmlChar const   *function ;
   xmlChar const   *functionURI ;
   xmlXPathFunction (*funcLookupFunc)(void *ctxt , xmlChar const   *name ,
                                      xmlChar const   *ns_uri ) ;
   void *funcLookupData ;
   xmlNsPtr *tmpNsList ;
   int tmpNsNr ;
   void *userData ;
   void (*error)(void *userData , xmlErrorPtr error ) ;
   xmlError lastError ;
   xmlNodePtr debugNode ;
   xmlDictPtr dict ;
   int flags ;
   void *cache ;
};
typedef xmlXPathFunction (*xmlXPathFuncLookupFunc)(void *ctxt ,
                                                   xmlChar const   *name ,
                                                   xmlChar const   *ns_uri );
typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc)(void *ctxt ,
                                                        xmlChar const   *name ,
                                                        xmlChar const   *ns_uri );
struct _xmlXPathAxis {
   xmlChar const   *name ;
   xmlXPathObjectPtr (*func)(xmlXPathParserContextPtr ctxt ,
                             xmlXPathObjectPtr cur ) ;
};
typedef xmlXPathObjectPtr (*xmlXPathAxisFunc)(xmlXPathParserContextPtr ctxt ,
                                              xmlXPathObjectPtr cur );
struct _xmlXPathFunct {
   xmlChar const   *name ;
   void (*func)(xmlXPathParserContextPtr ctxt , int nargs ) ;
};
struct _xmlXPathFunct;
typedef struct _xmlXPathFunct xmlXPathFunct;
typedef xmlXPathFunct *xmlXPathFuncPtr;
typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt , int nargs );
struct _xmlXPathVariable {
   xmlChar const   *name ;
   xmlXPathObjectPtr value ;
};
struct _xmlXPathVariable;
typedef struct _xmlXPathVariable xmlXPathVariable;
typedef xmlXPathVariable *xmlXPathVariablePtr;
struct _xmlXPathType {
   xmlChar const   *name ;
   int (*func)(xmlXPathObjectPtr obj , int type ) ;
};
typedef int (*xmlXPathConvertFunc)(xmlXPathObjectPtr obj , int type );
enum __anonenum_xmlXPathObjectType_104 {
    XPATH_UNDEFINED = 0,
    XPATH_NODESET = 1,
    XPATH_BOOLEAN = 2,
    XPATH_NUMBER = 3,
    XPATH_STRING = 4,
    XPATH_POINT = 5,
    XPATH_RANGE = 6,
    XPATH_LOCATIONSET = 7,
    XPATH_USERS = 8,
    XPATH_XSLT_TREE = 9
} ;
typedef enum __anonenum_xmlXPathObjectType_104 xmlXPathObjectType;
struct _xmlXPathObject {
   xmlXPathObjectType type ;
   xmlNodeSetPtr nodesetval ;
   int boolval ;
   double floatval ;
   xmlChar *stringval ;
   void *user ;
   int index ;
   void *user2 ;
   int index2 ;
};
enum __anonenum_xmlXPathObjectType_104;
struct _xmlNodeSet {
   int nodeNr ;
   int nodeMax ;
   xmlNodePtr *nodeTab ;
};
enum __anonenum_xmlXPathError_103;
typedef enum __anonenum_xmlXPathError_103 xmlXPathError;
enum __anonenum_xmlXPathError_103 {
    XPATH_EXPRESSION_OK = 0,
    XPATH_NUMBER_ERROR = 1,
    XPATH_UNFINISHED_LITERAL_ERROR = 2,
    XPATH_START_LITERAL_ERROR = 3,
    XPATH_VARIABLE_REF_ERROR = 4,
    XPATH_UNDEF_VARIABLE_ERROR = 5,
    XPATH_INVALID_PREDICATE_ERROR = 6,
    XPATH_EXPR_ERROR = 7,
    XPATH_UNCLOSED_ERROR = 8,
    XPATH_UNKNOWN_FUNC_ERROR = 9,
    XPATH_INVALID_OPERAND = 10,
    XPATH_INVALID_TYPE = 11,
    XPATH_INVALID_ARITY = 12,
    XPATH_INVALID_CTXT_SIZE = 13,
    XPATH_INVALID_CTXT_POSITION = 14,
    XPATH_MEMORY_ERROR = 15,
    XPTR_SYNTAX_ERROR = 16,
    XPTR_RESOURCE_ERROR = 17,
    XPTR_SUB_RESOURCE_ERROR = 18,
    XPATH_UNDEF_PREFIX_ERROR = 19,
    XPATH_ENCODING_ERROR = 20,
    XPATH_INVALID_CHAR_ERROR = 21,
    XPATH_INVALID_CTXT = 22
} ;
typedef void (*xmlEntityReferenceFunc)(xmlEntityPtr ent , xmlNodePtr firstNode ,
                                       xmlNodePtr lastNode );
struct _xmlChLRange;
typedef struct _xmlChLRange xmlChLRange;
struct _xmlChSRange;
typedef struct _xmlChSRange xmlChSRange;
struct _xmlChRangeGroup {
   int nbShortRange ;
   int nbLongRange ;
   xmlChSRange const   *shortRange ;
   xmlChLRange const   *longRange ;
};
typedef xmlChRangeGroup *xmlChRangeGroupPtr;
struct _xmlChLRange {
   unsigned int low ;
   unsigned int high ;
};
typedef xmlChLRange *xmlChLRangePtr;
struct _xmlChSRange {
   unsigned short low ;
   unsigned short high ;
};
typedef xmlChSRange *xmlChSRangePtr;
enum __anonenum_htmlStatus_102 {
    HTML_NA = 0,
    HTML_INVALID = 1,
    HTML_DEPRECATED = 2,
    HTML_VALID = 4,
    HTML_REQUIRED = 12
} ;
enum __anonenum_htmlParserOption_101;
typedef enum __anonenum_htmlParserOption_101 htmlParserOption;
enum __anonenum_htmlParserOption_101 {
    HTML_PARSE_RECOVER = 1,
    HTML_PARSE_NOERROR = 32,
    HTML_PARSE_NOWARNING = 64,
    HTML_PARSE_PEDANTIC = 128,
    HTML_PARSE_NOBLANKS = 256,
    HTML_PARSE_NONET = 2048,
    HTML_PARSE_NOIMPLIED = 8192,
    HTML_PARSE_COMPACT = 65536
} ;
struct _htmlEntityDesc {
   unsigned int value ;
   char const   *name ;
   char const   *desc ;
};
typedef htmlEntityDesc *htmlEntityDescPtr;
struct _htmlElemDesc {
   char const   *name ;
   char startTag ;
   char endTag ;
   char saveEndTag ;
   char empty ;
   char depr ;
   char dtd ;
   char isinline ;
   char const   *desc ;
   char const   **subelts ;
   char const   *defaultsubelt ;
   char const   **attrs_opt ;
   char const   **attrs_depr ;
   char const   **attrs_req ;
};
typedef htmlElemDesc *htmlElemDescPtr;
typedef xmlParserInputPtr htmlParserInputPtr;
typedef xmlParserInput htmlParserInput;
typedef xmlSAXHandler htmlSAXHandler;
typedef xmlParserNodeInfo htmlParserNodeInfo;
typedef xmlParserCtxt htmlParserCtxt;
enum __anonenum_xmlFeature_100 {
    XML_WITH_THREAD = 1,
    XML_WITH_TREE = 2,
    XML_WITH_OUTPUT = 3,
    XML_WITH_PUSH = 4,
    XML_WITH_READER = 5,
    XML_WITH_PATTERN = 6,
    XML_WITH_WRITER = 7,
    XML_WITH_SAX1 = 8,
    XML_WITH_FTP = 9,
    XML_WITH_HTTP = 10,
    XML_WITH_VALID = 11,
    XML_WITH_HTML = 12,
    XML_WITH_LEGACY = 13,
    XML_WITH_C14N = 14,
    XML_WITH_CATALOG = 15,
    XML_WITH_XPATH = 16,
    XML_WITH_XPTR = 17,
    XML_WITH_XINCLUDE = 18,
    XML_WITH_ICONV = 19,
    XML_WITH_ISO8859X = 20,
    XML_WITH_UNICODE = 21,
    XML_WITH_REGEXP = 22,
    XML_WITH_AUTOMATA = 23,
    XML_WITH_EXPR = 24,
    XML_WITH_SCHEMAS = 25,
    XML_WITH_SCHEMATRON = 26,
    XML_WITH_MODULES = 27,
    XML_WITH_DEBUG = 28,
    XML_WITH_DEBUG_MEM = 29,
    XML_WITH_DEBUG_RUN = 30,
    XML_WITH_ZLIB = 31,
    XML_WITH_NONE = 99999
} ;
enum __anonenum_xmlParserOption_99;
typedef enum __anonenum_xmlParserOption_99 xmlParserOption;
enum __anonenum_xmlParserOption_99 {
    XML_PARSE_RECOVER = 1,
    XML_PARSE_NOENT = 2,
    XML_PARSE_DTDLOAD = 4,
    XML_PARSE_DTDATTR = 8,
    XML_PARSE_DTDVALID = 16,
    XML_PARSE_NOERROR = 32,
    XML_PARSE_NOWARNING = 64,
    XML_PARSE_PEDANTIC = 128,
    XML_PARSE_NOBLANKS = 256,
    XML_PARSE_SAX1 = 512,
    XML_PARSE_XINCLUDE = 1024,
    XML_PARSE_NONET = 2048,
    XML_PARSE_NODICT = 4096,
    XML_PARSE_NSCLEAN = 8192,
    XML_PARSE_NOCDATA = 16384,
    XML_PARSE_NOXINCNODE = 32768,
    XML_PARSE_COMPACT = 65536,
    XML_PARSE_OLD10 = 131072,
    XML_PARSE_NOBASEFIX = 262144,
    XML_PARSE_HUGE = 524288,
    XML_PARSE_OLDSAX = 1048576
} ;
struct _xmlOutputBuffer {
   void *context ;
   int (*writecallback)(void *context , char const   *buffer , int len ) ;
   int (*closecallback)(void *context ) ;
   xmlCharEncodingHandlerPtr encoder ;
   xmlBufferPtr buffer ;
   xmlBufferPtr conv ;
   int written ;
   int error ;
};
struct _xmlParserInputBuffer {
   void *context ;
   int (*readcallback)(void *context , char *buffer , int len ) ;
   int (*closecallback)(void *context ) ;
   xmlCharEncodingHandlerPtr encoder ;
   xmlBufferPtr buffer ;
   xmlBufferPtr raw ;
   int compressed ;
   int error ;
   unsigned long rawconsumed ;
};
enum __anonenum_xmlCharEncoding_95 {
    XML_CHAR_ENCODING_ERROR = -1,
    XML_CHAR_ENCODING_NONE = 0,
    XML_CHAR_ENCODING_UTF8 = 1,
    XML_CHAR_ENCODING_UTF16LE = 2,
    XML_CHAR_ENCODING_UTF16BE = 3,
    XML_CHAR_ENCODING_UCS4LE = 4,
    XML_CHAR_ENCODING_UCS4BE = 5,
    XML_CHAR_ENCODING_EBCDIC = 6,
    XML_CHAR_ENCODING_UCS4_2143 = 7,
    XML_CHAR_ENCODING_UCS4_3412 = 8,
    XML_CHAR_ENCODING_UCS2 = 9,
    XML_CHAR_ENCODING_8859_1 = 10,
    XML_CHAR_ENCODING_8859_2 = 11,
    XML_CHAR_ENCODING_8859_3 = 12,
    XML_CHAR_ENCODING_8859_4 = 13,
    XML_CHAR_ENCODING_8859_5 = 14,
    XML_CHAR_ENCODING_8859_6 = 15,
    XML_CHAR_ENCODING_8859_7 = 16,
    XML_CHAR_ENCODING_8859_8 = 17,
    XML_CHAR_ENCODING_8859_9 = 18,
    XML_CHAR_ENCODING_2022_JP = 19,
    XML_CHAR_ENCODING_SHIFT_JIS = 20,
    XML_CHAR_ENCODING_EUC_JP = 21,
    XML_CHAR_ENCODING_ASCII = 22
} ;
enum __anonenum_xmlBufferAllocationScheme_80 {
    XML_BUFFER_ALLOC_DOUBLEIT = 0,
    XML_BUFFER_ALLOC_EXACT = 1,
    XML_BUFFER_ALLOC_IMMUTABLE = 2,
    XML_BUFFER_ALLOC_IO = 3
} ;
struct _xmlSAXHandlerV1 {
   void (*internalSubset)(void *ctx , xmlChar const   *name ,
                          xmlChar const   *ExternalID ,
                          xmlChar const   *SystemID ) ;
   int (*isStandalone)(void *ctx ) ;
   int (*hasInternalSubset)(void *ctx ) ;
   int (*hasExternalSubset)(void *ctx ) ;
   xmlParserInputPtr (*resolveEntity)(void *ctx , xmlChar const   *publicId ,
                                      xmlChar const   *systemId ) ;
   xmlEntityPtr (*getEntity)(void *ctx , xmlChar const   *name ) ;
   void (*entityDecl)(void *ctx , xmlChar const   *name , int type ,
                      xmlChar const   *publicId , xmlChar const   *systemId ,
                      xmlChar *content ) ;
   void (*notationDecl)(void *ctx , xmlChar const   *name ,
                        xmlChar const   *publicId , xmlChar const   *systemId ) ;
   void (*attributeDecl)(void *ctx , xmlChar const   *elem ,
                         xmlChar const   *fullname , int type , int def ,
                         xmlChar const   *defaultValue , xmlEnumerationPtr tree ) ;
   void (*elementDecl)(void *ctx , xmlChar const   *name , int type ,
                       xmlElementContentPtr content ) ;
   void (*unparsedEntityDecl)(void *ctx , xmlChar const   *name ,
                              xmlChar const   *publicId ,
                              xmlChar const   *systemId ,
                              xmlChar const   *notationName ) ;
   void (*setDocumentLocator)(void *ctx , xmlSAXLocatorPtr loc ) ;
   void (*startDocument)(void *ctx ) ;
   void (*endDocument)(void *ctx ) ;
   void (*startElement)(void *ctx , xmlChar const   *name ,
                        xmlChar const   **atts ) ;
   void (*endElement)(void *ctx , xmlChar const   *name ) ;
   void (*reference)(void *ctx , xmlChar const   *name ) ;
   void (*characters)(void *ctx , xmlChar const   *ch , int len ) ;
   void (*ignorableWhitespace)(void *ctx , xmlChar const   *ch , int len ) ;
   void (*processingInstruction)(void *ctx , xmlChar const   *target ,
                                 xmlChar const   *data ) ;
   void (*comment)(void *ctx , xmlChar const   *value ) ;
   void ( /* format attribute */  (*warning))(void *ctx , char const   *msg 
                                              , ...) ;
   void ( /* format attribute */  (*error))(void *ctx , char const   *msg  , ...) ;
   void ( /* format attribute */  (*fatalError))(void *ctx , char const   *msg 
                                                 , ...) ;
   xmlEntityPtr (*getParameterEntity)(void *ctx , xmlChar const   *name ) ;
   void (*cdataBlock)(void *ctx , xmlChar const   *value , int len ) ;
   void (*externalSubset)(void *ctx , xmlChar const   *name ,
                          xmlChar const   *ExternalID ,
                          xmlChar const   *SystemID ) ;
   unsigned int initialized ;
};
struct _xmlSAXLocator {
   xmlChar const   *(*getPublicId)(void *ctx ) ;
   xmlChar const   *(*getSystemId)(void *ctx ) ;
   int (*getLineNumber)(void *ctx ) ;
   int (*getColumnNumber)(void *ctx ) ;
};
struct _xmlGlobalState {
   char const   *xmlParserVersion ;
   xmlSAXLocator xmlDefaultSAXLocator ;
   xmlSAXHandlerV1 xmlDefaultSAXHandler ;
   xmlSAXHandlerV1 docbDefaultSAXHandler ;
   xmlSAXHandlerV1 htmlDefaultSAXHandler ;
   void (*xmlFree)(void *mem ) ;
   void *( __attribute__((__alloc_size__(1))) (*xmlMalloc))(size_t size ) ;
   char *(*xmlMemStrdup)(char const   *str ) ;
   void *(*xmlRealloc)(void *mem , size_t size ) ;
   void ( /* format attribute */  (*xmlGenericError))(void *ctx ,
                                                      char const   *msg  , ...) ;
   void (*xmlStructuredError)(void *userData , xmlErrorPtr error ) ;
   void *xmlGenericErrorContext ;
   int oldXMLWDcompatibility ;
   xmlBufferAllocationScheme xmlBufferAllocScheme ;
   int xmlDefaultBufferSize ;
   int xmlSubstituteEntitiesDefaultValue ;
   int xmlDoValidityCheckingDefaultValue ;
   int xmlGetWarningsDefaultValue ;
   int xmlKeepBlanksDefaultValue ;
   int xmlLineNumbersDefaultValue ;
   int xmlLoadExtDtdDefaultValue ;
   int xmlParserDebugEntities ;
   int xmlPedanticParserDefaultValue ;
   int xmlSaveNoEmptyTags ;
   int xmlIndentTreeOutput ;
   char const   *xmlTreeIndentString ;
   void (*xmlRegisterNodeDefaultValue)(xmlNodePtr node ) ;
   void (*xmlDeregisterNodeDefaultValue)(xmlNodePtr node ) ;
   void *( __attribute__((__alloc_size__(1))) (*xmlMallocAtomic))(size_t size ) ;
   xmlError xmlLastError ;
   xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameValue)(char const   *URI ,
                                                                      xmlCharEncoding enc ) ;
   xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameValue)(char const   *URI ,
                                                            xmlCharEncodingHandlerPtr encoder ,
                                                            int compression ) ;
   void *xmlStructuredErrorContext ;
};
typedef xmlChar *xlinkTitle;
typedef xmlChar *xlinkRole;
typedef xmlChar *xlinkHRef;
enum __anonenum_xlinkActuate_98;
typedef enum __anonenum_xlinkActuate_98 xlinkActuate;
enum __anonenum_xlinkShow_97;
typedef enum __anonenum_xlinkShow_97 xlinkShow;
struct _xlinkHandler {
   void (*simple)(void *ctx , xmlNodePtr node , xlinkHRef href ,
                  xlinkRole role , xlinkTitle title ) ;
   void (*extended)(void *ctx , xmlNodePtr node , int nbLocators ,
                    xlinkHRef const   *hrefs , xlinkRole const   *roles ,
                    int nbArcs , xlinkRole const   *from ,
                    xlinkRole const   *to , xlinkShow *show ,
                    xlinkActuate *actuate , int nbTitles ,
                    xlinkTitle const   *titles , xmlChar const   **langs ) ;
   void (*set)(void *ctx , xmlNodePtr node , int nbLocators ,
               xlinkHRef const   *hrefs , xlinkRole const   *roles ,
               int nbTitles , xlinkTitle const   *titles ,
               xmlChar const   **langs ) ;
};
typedef void (*xlinkExtendedLinkSetFunk)(void *ctx , xmlNodePtr node ,
                                         int nbLocators ,
                                         xlinkHRef const   *hrefs ,
                                         xlinkRole const   *roles ,
                                         int nbTitles ,
                                         xlinkTitle const   *titles ,
                                         xmlChar const   **langs );
typedef void (*xlinkExtendedLinkFunk)(void *ctx , xmlNodePtr node ,
                                      int nbLocators ,
                                      xlinkHRef const   *hrefs ,
                                      xlinkRole const   *roles , int nbArcs ,
                                      xlinkRole const   *from ,
                                      xlinkRole const   *to , xlinkShow *show ,
                                      xlinkActuate *actuate , int nbTitles ,
                                      xlinkTitle const   *titles ,
                                      xmlChar const   **langs );
typedef void (*xlinkSimpleLinkFunk)(void *ctx , xmlNodePtr node ,
                                    xlinkHRef href , xlinkRole role ,
                                    xlinkTitle title );
enum __anonenum_xlinkActuate_98 {
    XLINK_ACTUATE_NONE = 0,
    XLINK_ACTUATE_AUTO = 1,
    XLINK_ACTUATE_ONREQUEST = 2
} ;
enum __anonenum_xlinkShow_97 {
    XLINK_SHOW_NONE = 0,
    XLINK_SHOW_NEW = 1,
    XLINK_SHOW_EMBED = 2,
    XLINK_SHOW_REPLACE = 3
} ;
enum __anonenum_xlinkType_96 {
    XLINK_TYPE_NONE = 0,
    XLINK_TYPE_SIMPLE = 1,
    XLINK_TYPE_EXTENDED = 2,
    XLINK_TYPE_EXTENDED_SET = 3
} ;
typedef int (*xmlOutputCloseCallback)(void *context );
typedef int (*xmlOutputWriteCallback)(void *context , char const   *buffer ,
                                      int len );
typedef void *(*xmlOutputOpenCallback)(char const   *filename );
typedef int (*xmlOutputMatchCallback)(char const   *filename );
typedef int (*xmlInputCloseCallback)(void *context );
typedef int (*xmlInputReadCallback)(void *context , char *buffer , int len );
typedef void *(*xmlInputOpenCallback)(char const   *filename );
typedef int (*xmlInputMatchCallback)(char const   *filename );
struct _xmlCharEncodingHandler {
   char *name ;
   int (*input)(unsigned char *out , int *outlen , unsigned char const   *in ,
                int *inlen ) ;
   int (*output)(unsigned char *out , int *outlen , unsigned char const   *in ,
                 int *inlen ) ;
   iconv_t iconv_in ;
   iconv_t iconv_out ;
};
typedef int (*xmlCharEncodingOutputFunc)(unsigned char *out , int *outlen ,
                                         unsigned char const   *in , int *inlen );
typedef int (*xmlCharEncodingInputFunc)(unsigned char *out , int *outlen ,
                                        unsigned char const   *in , int *inlen );
typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr;
typedef void (*endElementNsSAX2Func)(void *ctx , xmlChar const   *localname ,
                                     xmlChar const   *prefix ,
                                     xmlChar const   *URI );
typedef void (*startElementNsSAX2Func)(void *ctx , xmlChar const   *localname ,
                                       xmlChar const   *prefix ,
                                       xmlChar const   *URI ,
                                       int nb_namespaces ,
                                       xmlChar const   **namespaces ,
                                       int nb_attributes , int nb_defaulted ,
                                       xmlChar const   **attributes );
typedef int (*hasExternalSubsetSAXFunc)(void *ctx );
typedef int (*hasInternalSubsetSAXFunc)(void *ctx );
typedef int (*isStandaloneSAXFunc)(void *ctx );
typedef void ( /* format attribute */  (*fatalErrorSAXFunc))(void *ctx ,
                                                             char const   *msg 
                                                             , ...);
typedef void ( /* format attribute */  (*errorSAXFunc))(void *ctx ,
                                                        char const   *msg  , ...);
typedef void ( /* format attribute */  (*warningSAXFunc))(void *ctx ,
                                                          char const   *msg 
                                                          , ...);
typedef void (*cdataBlockSAXFunc)(void *ctx , xmlChar const   *value , int len );
typedef void (*commentSAXFunc)(void *ctx , xmlChar const   *value );
typedef void (*processingInstructionSAXFunc)(void *ctx ,
                                             xmlChar const   *target ,
                                             xmlChar const   *data );
typedef void (*ignorableWhitespaceSAXFunc)(void *ctx , xmlChar const   *ch ,
                                           int len );
typedef void (*charactersSAXFunc)(void *ctx , xmlChar const   *ch , int len );
typedef void (*referenceSAXFunc)(void *ctx , xmlChar const   *name );
typedef void (*attributeSAXFunc)(void *ctx , xmlChar const   *name ,
                                 xmlChar const   *value );
typedef void (*endElementSAXFunc)(void *ctx , xmlChar const   *name );
typedef void (*startElementSAXFunc)(void *ctx , xmlChar const   *name ,
                                    xmlChar const   **atts );
typedef void (*endDocumentSAXFunc)(void *ctx );
typedef void (*startDocumentSAXFunc)(void *ctx );
typedef void (*setDocumentLocatorSAXFunc)(void *ctx , xmlSAXLocatorPtr loc );
typedef void (*unparsedEntityDeclSAXFunc)(void *ctx , xmlChar const   *name ,
                                          xmlChar const   *publicId ,
                                          xmlChar const   *systemId ,
                                          xmlChar const   *notationName );
typedef void (*elementDeclSAXFunc)(void *ctx , xmlChar const   *name ,
                                   int type , xmlElementContentPtr content );
typedef void (*attributeDeclSAXFunc)(void *ctx , xmlChar const   *elem ,
                                     xmlChar const   *fullname , int type ,
                                     int def , xmlChar const   *defaultValue ,
                                     xmlEnumerationPtr tree );
typedef void (*notationDeclSAXFunc)(void *ctx , xmlChar const   *name ,
                                    xmlChar const   *publicId ,
                                    xmlChar const   *systemId );
typedef void (*entityDeclSAXFunc)(void *ctx , xmlChar const   *name , int type ,
                                  xmlChar const   *publicId ,
                                  xmlChar const   *systemId , xmlChar *content );
typedef xmlEntityPtr (*getParameterEntitySAXFunc)(void *ctx ,
                                                  xmlChar const   *name );
typedef xmlEntityPtr (*getEntitySAXFunc)(void *ctx , xmlChar const   *name );
typedef void (*externalSubsetSAXFunc)(void *ctx , xmlChar const   *name ,
                                      xmlChar const   *ExternalID ,
                                      xmlChar const   *SystemID );
typedef void (*internalSubsetSAXFunc)(void *ctx , xmlChar const   *name ,
                                      xmlChar const   *ExternalID ,
                                      xmlChar const   *SystemID );
typedef xmlParserInputPtr (*resolveEntitySAXFunc)(void *ctx ,
                                                  xmlChar const   *publicId ,
                                                  xmlChar const   *systemId );
enum __anonenum_xmlParserMode_94;
enum __anonenum_xmlParserInputState_93;
struct _xmlParserNodeInfo {
   struct _xmlNode  const  *node ;
   unsigned long begin_pos ;
   unsigned long begin_line ;
   unsigned long end_pos ;
   unsigned long end_line ;
};
struct _xmlParserInput {
   xmlParserInputBufferPtr buf ;
   char const   *filename ;
   char const   *directory ;
   xmlChar const   *base ;
   xmlChar const   *cur ;
   xmlChar const   *end ;
   int length ;
   int line ;
   int col ;
   unsigned long consumed ;
   void (*free)(xmlChar *str ) ;
   xmlChar const   *encoding ;
   xmlChar const   *version ;
   int standalone ;
   int id ;
};
typedef void (*xmlParserInputDeallocate)(xmlChar *str );
enum __anonenum_xmlEntityType_92 {
    XML_INTERNAL_GENERAL_ENTITY = 1,
    XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2,
    XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3,
    XML_INTERNAL_PARAMETER_ENTITY = 4,
    XML_EXTERNAL_PARAMETER_ENTITY = 5,
    XML_INTERNAL_PREDEFINED_ENTITY = 6
} ;
typedef enum __anonenum_xmlEntityType_92 xmlEntityType;
struct _xmlEntity {
   void *_private ;
   xmlElementType type ;
   xmlChar const   *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlDtd *parent ;
   struct _xmlNode *next ;
   struct _xmlNode *prev ;
   struct _xmlDoc *doc ;
   xmlChar *orig ;
   xmlChar *content ;
   int length ;
   xmlEntityType etype ;
   xmlChar const   *ExternalID ;
   xmlChar const   *SystemID ;
   struct _xmlEntity *nexte ;
   xmlChar const   *URI ;
   int owner ;
   int checked ;
};
enum __anonenum_xmlEntityType_92;
typedef void ( /* format attribute */  (*xmlValidityWarningFunc))(void *ctx ,
                                                                  char const   *msg 
                                                                  , ...);
typedef void ( /* format attribute */  (*xmlValidityErrorFunc))(void *ctx ,
                                                                char const   *msg 
                                                                , ...);
typedef xmlValidState *xmlValidStatePtr;
typedef int (*xmlListWalker)(void const   *data , void const   *user );
typedef int (*xmlListDataCompare)(void const   *data0 , void const   *data1 );
typedef void (*xmlListDeallocator)(xmlLinkPtr lk );
enum __anonenum_xmlParserErrors_91 {
    XML_ERR_OK = 0,
    XML_ERR_INTERNAL_ERROR = 1,
    XML_ERR_NO_MEMORY = 2,
    XML_ERR_DOCUMENT_START = 3,
    XML_ERR_DOCUMENT_EMPTY = 4,
    XML_ERR_DOCUMENT_END = 5,
    XML_ERR_INVALID_HEX_CHARREF = 6,
    XML_ERR_INVALID_DEC_CHARREF = 7,
    XML_ERR_INVALID_CHARREF = 8,
    XML_ERR_INVALID_CHAR = 9,
    XML_ERR_CHARREF_AT_EOF = 10,
    XML_ERR_CHARREF_IN_PROLOG = 11,
    XML_ERR_CHARREF_IN_EPILOG = 12,
    XML_ERR_CHARREF_IN_DTD = 13,
    XML_ERR_ENTITYREF_AT_EOF = 14,
    XML_ERR_ENTITYREF_IN_PROLOG = 15,
    XML_ERR_ENTITYREF_IN_EPILOG = 16,
    XML_ERR_ENTITYREF_IN_DTD = 17,
    XML_ERR_PEREF_AT_EOF = 18,
    XML_ERR_PEREF_IN_PROLOG = 19,
    XML_ERR_PEREF_IN_EPILOG = 20,
    XML_ERR_PEREF_IN_INT_SUBSET = 21,
    XML_ERR_ENTITYREF_NO_NAME = 22,
    XML_ERR_ENTITYREF_SEMICOL_MISSING = 23,
    XML_ERR_PEREF_NO_NAME = 24,
    XML_ERR_PEREF_SEMICOL_MISSING = 25,
    XML_ERR_UNDECLARED_ENTITY = 26,
    XML_WAR_UNDECLARED_ENTITY = 27,
    XML_ERR_UNPARSED_ENTITY = 28,
    XML_ERR_ENTITY_IS_EXTERNAL = 29,
    XML_ERR_ENTITY_IS_PARAMETER = 30,
    XML_ERR_UNKNOWN_ENCODING = 31,
    XML_ERR_UNSUPPORTED_ENCODING = 32,
    XML_ERR_STRING_NOT_STARTED = 33,
    XML_ERR_STRING_NOT_CLOSED = 34,
    XML_ERR_NS_DECL_ERROR = 35,
    XML_ERR_ENTITY_NOT_STARTED = 36,
    XML_ERR_ENTITY_NOT_FINISHED = 37,
    XML_ERR_LT_IN_ATTRIBUTE = 38,
    XML_ERR_ATTRIBUTE_NOT_STARTED = 39,
    XML_ERR_ATTRIBUTE_NOT_FINISHED = 40,
    XML_ERR_ATTRIBUTE_WITHOUT_VALUE = 41,
    XML_ERR_ATTRIBUTE_REDEFINED = 42,
    XML_ERR_LITERAL_NOT_STARTED = 43,
    XML_ERR_LITERAL_NOT_FINISHED = 44,
    XML_ERR_COMMENT_NOT_FINISHED = 45,
    XML_ERR_PI_NOT_STARTED = 46,
    XML_ERR_PI_NOT_FINISHED = 47,
    XML_ERR_NOTATION_NOT_STARTED = 48,
    XML_ERR_NOTATION_NOT_FINISHED = 49,
    XML_ERR_ATTLIST_NOT_STARTED = 50,
    XML_ERR_ATTLIST_NOT_FINISHED = 51,
    XML_ERR_MIXED_NOT_STARTED = 52,
    XML_ERR_MIXED_NOT_FINISHED = 53,
    XML_ERR_ELEMCONTENT_NOT_STARTED = 54,
    XML_ERR_ELEMCONTENT_NOT_FINISHED = 55,
    XML_ERR_XMLDECL_NOT_STARTED = 56,
    XML_ERR_XMLDECL_NOT_FINISHED = 57,
    XML_ERR_CONDSEC_NOT_STARTED = 58,
    XML_ERR_CONDSEC_NOT_FINISHED = 59,
    XML_ERR_EXT_SUBSET_NOT_FINISHED = 60,
    XML_ERR_DOCTYPE_NOT_FINISHED = 61,
    XML_ERR_MISPLACED_CDATA_END = 62,
    XML_ERR_CDATA_NOT_FINISHED = 63,
    XML_ERR_RESERVED_XML_NAME = 64,
    XML_ERR_SPACE_REQUIRED = 65,
    XML_ERR_SEPARATOR_REQUIRED = 66,
    XML_ERR_NMTOKEN_REQUIRED = 67,
    XML_ERR_NAME_REQUIRED = 68,
    XML_ERR_PCDATA_REQUIRED = 69,
    XML_ERR_URI_REQUIRED = 70,
    XML_ERR_PUBID_REQUIRED = 71,
    XML_ERR_LT_REQUIRED = 72,
    XML_ERR_GT_REQUIRED = 73,
    XML_ERR_LTSLASH_REQUIRED = 74,
    XML_ERR_EQUAL_REQUIRED = 75,
    XML_ERR_TAG_NAME_MISMATCH = 76,
    XML_ERR_TAG_NOT_FINISHED = 77,
    XML_ERR_STANDALONE_VALUE = 78,
    XML_ERR_ENCODING_NAME = 79,
    XML_ERR_HYPHEN_IN_COMMENT = 80,
    XML_ERR_INVALID_ENCODING = 81,
    XML_ERR_EXT_ENTITY_STANDALONE = 82,
    XML_ERR_CONDSEC_INVALID = 83,
    XML_ERR_VALUE_REQUIRED = 84,
    XML_ERR_NOT_WELL_BALANCED = 85,
    XML_ERR_EXTRA_CONTENT = 86,
    XML_ERR_ENTITY_CHAR_ERROR = 87,
    XML_ERR_ENTITY_PE_INTERNAL = 88,
    XML_ERR_ENTITY_LOOP = 89,
    XML_ERR_ENTITY_BOUNDARY = 90,
    XML_ERR_INVALID_URI = 91,
    XML_ERR_URI_FRAGMENT = 92,
    XML_WAR_CATALOG_PI = 93,
    XML_ERR_NO_DTD = 94,
    XML_ERR_CONDSEC_INVALID_KEYWORD = 95,
    XML_ERR_VERSION_MISSING = 96,
    XML_WAR_UNKNOWN_VERSION = 97,
    XML_WAR_LANG_VALUE = 98,
    XML_WAR_NS_URI = 99,
    XML_WAR_NS_URI_RELATIVE = 100,
    XML_ERR_MISSING_ENCODING = 101,
    XML_WAR_SPACE_VALUE = 102,
    XML_ERR_NOT_STANDALONE = 103,
    XML_ERR_ENTITY_PROCESSING = 104,
    XML_ERR_NOTATION_PROCESSING = 105,
    XML_WAR_NS_COLUMN = 106,
    XML_WAR_ENTITY_REDEFINED = 107,
    XML_ERR_UNKNOWN_VERSION = 108,
    XML_ERR_VERSION_MISMATCH = 109,
    XML_NS_ERR_XML_NAMESPACE = 200,
    XML_NS_ERR_UNDEFINED_NAMESPACE = 201,
    XML_NS_ERR_QNAME = 202,
    XML_NS_ERR_ATTRIBUTE_REDEFINED = 203,
    XML_NS_ERR_EMPTY = 204,
    XML_NS_ERR_COLON = 205,
    XML_DTD_ATTRIBUTE_DEFAULT = 500,
    XML_DTD_ATTRIBUTE_REDEFINED = 501,
    XML_DTD_ATTRIBUTE_VALUE = 502,
    XML_DTD_CONTENT_ERROR = 503,
    XML_DTD_CONTENT_MODEL = 504,
    XML_DTD_CONTENT_NOT_DETERMINIST = 505,
    XML_DTD_DIFFERENT_PREFIX = 506,
    XML_DTD_ELEM_DEFAULT_NAMESPACE = 507,
    XML_DTD_ELEM_NAMESPACE = 508,
    XML_DTD_ELEM_REDEFINED = 509,
    XML_DTD_EMPTY_NOTATION = 510,
    XML_DTD_ENTITY_TYPE = 511,
    XML_DTD_ID_FIXED = 512,
    XML_DTD_ID_REDEFINED = 513,
    XML_DTD_ID_SUBSET = 514,
    XML_DTD_INVALID_CHILD = 515,
    XML_DTD_INVALID_DEFAULT = 516,
    XML_DTD_LOAD_ERROR = 517,
    XML_DTD_MISSING_ATTRIBUTE = 518,
    XML_DTD_MIXED_CORRUPT = 519,
    XML_DTD_MULTIPLE_ID = 520,
    XML_DTD_NO_DOC = 521,
    XML_DTD_NO_DTD = 522,
    XML_DTD_NO_ELEM_NAME = 523,
    XML_DTD_NO_PREFIX = 524,
    XML_DTD_NO_ROOT = 525,
    XML_DTD_NOTATION_REDEFINED = 526,
    XML_DTD_NOTATION_VALUE = 527,
    XML_DTD_NOT_EMPTY = 528,
    XML_DTD_NOT_PCDATA = 529,
    XML_DTD_NOT_STANDALONE = 530,
    XML_DTD_ROOT_NAME = 531,
    XML_DTD_STANDALONE_WHITE_SPACE = 532,
    XML_DTD_UNKNOWN_ATTRIBUTE = 533,
    XML_DTD_UNKNOWN_ELEM = 534,
    XML_DTD_UNKNOWN_ENTITY = 535,
    XML_DTD_UNKNOWN_ID = 536,
    XML_DTD_UNKNOWN_NOTATION = 537,
    XML_DTD_STANDALONE_DEFAULTED = 538,
    XML_DTD_XMLID_VALUE = 539,
    XML_DTD_XMLID_TYPE = 540,
    XML_DTD_DUP_TOKEN = 541,
    XML_HTML_STRUCURE_ERROR = 800,
    XML_HTML_UNKNOWN_TAG = 801,
    XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000,
    XML_RNGP_ATTR_CONFLICT = 1001,
    XML_RNGP_ATTRIBUTE_CHILDREN = 1002,
    XML_RNGP_ATTRIBUTE_CONTENT = 1003,
    XML_RNGP_ATTRIBUTE_EMPTY = 1004,
    XML_RNGP_ATTRIBUTE_NOOP = 1005,
    XML_RNGP_CHOICE_CONTENT = 1006,
    XML_RNGP_CHOICE_EMPTY = 1007,
    XML_RNGP_CREATE_FAILURE = 1008,
    XML_RNGP_DATA_CONTENT = 1009,
    XML_RNGP_DEF_CHOICE_AND_INTERLEAVE = 1010,
    XML_RNGP_DEFINE_CREATE_FAILED = 1011,
    XML_RNGP_DEFINE_EMPTY = 1012,
    XML_RNGP_DEFINE_MISSING = 1013,
    XML_RNGP_DEFINE_NAME_MISSING = 1014,
    XML_RNGP_ELEM_CONTENT_EMPTY = 1015,
    XML_RNGP_ELEM_CONTENT_ERROR = 1016,
    XML_RNGP_ELEMENT_EMPTY = 1017,
    XML_RNGP_ELEMENT_CONTENT = 1018,
    XML_RNGP_ELEMENT_NAME = 1019,
    XML_RNGP_ELEMENT_NO_CONTENT = 1020,
    XML_RNGP_ELEM_TEXT_CONFLICT = 1021,
    XML_RNGP_EMPTY = 1022,
    XML_RNGP_EMPTY_CONSTRUCT = 1023,
    XML_RNGP_EMPTY_CONTENT = 1024,
    XML_RNGP_EMPTY_NOT_EMPTY = 1025,
    XML_RNGP_ERROR_TYPE_LIB = 1026,
    XML_RNGP_EXCEPT_EMPTY = 1027,
    XML_RNGP_EXCEPT_MISSING = 1028,
    XML_RNGP_EXCEPT_MULTIPLE = 1029,
    XML_RNGP_EXCEPT_NO_CONTENT = 1030,
    XML_RNGP_EXTERNALREF_EMTPY = 1031,
    XML_RNGP_EXTERNAL_REF_FAILURE = 1032,
    XML_RNGP_EXTERNALREF_RECURSE = 1033,
    XML_RNGP_FORBIDDEN_ATTRIBUTE = 1034,
    XML_RNGP_FOREIGN_ELEMENT = 1035,
    XML_RNGP_GRAMMAR_CONTENT = 1036,
    XML_RNGP_GRAMMAR_EMPTY = 1037,
    XML_RNGP_GRAMMAR_MISSING = 1038,
    XML_RNGP_GRAMMAR_NO_START = 1039,
    XML_RNGP_GROUP_ATTR_CONFLICT = 1040,
    XML_RNGP_HREF_ERROR = 1041,
    XML_RNGP_INCLUDE_EMPTY = 1042,
    XML_RNGP_INCLUDE_FAILURE = 1043,
    XML_RNGP_INCLUDE_RECURSE = 1044,
    XML_RNGP_INTERLEAVE_ADD = 1045,
    XML_RNGP_INTERLEAVE_CREATE_FAILED = 1046,
    XML_RNGP_INTERLEAVE_EMPTY = 1047,
    XML_RNGP_INTERLEAVE_NO_CONTENT = 1048,
    XML_RNGP_INVALID_DEFINE_NAME = 1049,
    XML_RNGP_INVALID_URI = 1050,
    XML_RNGP_INVALID_VALUE = 1051,
    XML_RNGP_MISSING_HREF = 1052,
    XML_RNGP_NAME_MISSING = 1053,
    XML_RNGP_NEED_COMBINE = 1054,
    XML_RNGP_NOTALLOWED_NOT_EMPTY = 1055,
    XML_RNGP_NSNAME_ATTR_ANCESTOR = 1056,
    XML_RNGP_NSNAME_NO_NS = 1057,
    XML_RNGP_PARAM_FORBIDDEN = 1058,
    XML_RNGP_PARAM_NAME_MISSING = 1059,
    XML_RNGP_PARENTREF_CREATE_FAILED = 1060,
    XML_RNGP_PARENTREF_NAME_INVALID = 1061,
    XML_RNGP_PARENTREF_NO_NAME = 1062,
    XML_RNGP_PARENTREF_NO_PARENT = 1063,
    XML_RNGP_PARENTREF_NOT_EMPTY = 1064,
    XML_RNGP_PARSE_ERROR = 1065,
    XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME = 1066,
    XML_RNGP_PAT_ATTR_ATTR = 1067,
    XML_RNGP_PAT_ATTR_ELEM = 1068,
    XML_RNGP_PAT_DATA_EXCEPT_ATTR = 1069,
    XML_RNGP_PAT_DATA_EXCEPT_ELEM = 1070,
    XML_RNGP_PAT_DATA_EXCEPT_EMPTY = 1071,
    XML_RNGP_PAT_DATA_EXCEPT_GROUP = 1072,
    XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE = 1073,
    XML_RNGP_PAT_DATA_EXCEPT_LIST = 1074,
    XML_RNGP_PAT_DATA_EXCEPT_ONEMORE = 1075,
    XML_RNGP_PAT_DATA_EXCEPT_REF = 1076,
    XML_RNGP_PAT_DATA_EXCEPT_TEXT = 1077,
    XML_RNGP_PAT_LIST_ATTR = 1078,
    XML_RNGP_PAT_LIST_ELEM = 1079,
    XML_RNGP_PAT_LIST_INTERLEAVE = 1080,
    XML_RNGP_PAT_LIST_LIST = 1081,
    XML_RNGP_PAT_LIST_REF = 1082,
    XML_RNGP_PAT_LIST_TEXT = 1083,
    XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME = 1084,
    XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME = 1085,
    XML_RNGP_PAT_ONEMORE_GROUP_ATTR = 1086,
    XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR = 1087,
    XML_RNGP_PAT_START_ATTR = 1088,
    XML_RNGP_PAT_START_DATA = 1089,
    XML_RNGP_PAT_START_EMPTY = 1090,
    XML_RNGP_PAT_START_GROUP = 1091,
    XML_RNGP_PAT_START_INTERLEAVE = 1092,
    XML_RNGP_PAT_START_LIST = 1093,
    XML_RNGP_PAT_START_ONEMORE = 1094,
    XML_RNGP_PAT_START_TEXT = 1095,
    XML_RNGP_PAT_START_VALUE = 1096,
    XML_RNGP_PREFIX_UNDEFINED = 1097,
    XML_RNGP_REF_CREATE_FAILED = 1098,
    XML_RNGP_REF_CYCLE = 1099,
    XML_RNGP_REF_NAME_INVALID = 1100,
    XML_RNGP_REF_NO_DEF = 1101,
    XML_RNGP_REF_NO_NAME = 1102,
    XML_RNGP_REF_NOT_EMPTY = 1103,
    XML_RNGP_START_CHOICE_AND_INTERLEAVE = 1104,
    XML_RNGP_START_CONTENT = 1105,
    XML_RNGP_START_EMPTY = 1106,
    XML_RNGP_START_MISSING = 1107,
    XML_RNGP_TEXT_EXPECTED = 1108,
    XML_RNGP_TEXT_HAS_CHILD = 1109,
    XML_RNGP_TYPE_MISSING = 1110,
    XML_RNGP_TYPE_NOT_FOUND = 1111,
    XML_RNGP_TYPE_VALUE = 1112,
    XML_RNGP_UNKNOWN_ATTRIBUTE = 1113,
    XML_RNGP_UNKNOWN_COMBINE = 1114,
    XML_RNGP_UNKNOWN_CONSTRUCT = 1115,
    XML_RNGP_UNKNOWN_TYPE_LIB = 1116,
    XML_RNGP_URI_FRAGMENT = 1117,
    XML_RNGP_URI_NOT_ABSOLUTE = 1118,
    XML_RNGP_VALUE_EMPTY = 1119,
    XML_RNGP_VALUE_NO_CONTENT = 1120,
    XML_RNGP_XMLNS_NAME = 1121,
    XML_RNGP_XML_NS = 1122,
    XML_XPATH_EXPRESSION_OK = 1200,
    XML_XPATH_NUMBER_ERROR = 1201,
    XML_XPATH_UNFINISHED_LITERAL_ERROR = 1202,
    XML_XPATH_START_LITERAL_ERROR = 1203,
    XML_XPATH_VARIABLE_REF_ERROR = 1204,
    XML_XPATH_UNDEF_VARIABLE_ERROR = 1205,
    XML_XPATH_INVALID_PREDICATE_ERROR = 1206,
    XML_XPATH_EXPR_ERROR = 1207,
    XML_XPATH_UNCLOSED_ERROR = 1208,
    XML_XPATH_UNKNOWN_FUNC_ERROR = 1209,
    XML_XPATH_INVALID_OPERAND = 1210,
    XML_XPATH_INVALID_TYPE = 1211,
    XML_XPATH_INVALID_ARITY = 1212,
    XML_XPATH_INVALID_CTXT_SIZE = 1213,
    XML_XPATH_INVALID_CTXT_POSITION = 1214,
    XML_XPATH_MEMORY_ERROR = 1215,
    XML_XPTR_SYNTAX_ERROR = 1216,
    XML_XPTR_RESOURCE_ERROR = 1217,
    XML_XPTR_SUB_RESOURCE_ERROR = 1218,
    XML_XPATH_UNDEF_PREFIX_ERROR = 1219,
    XML_XPATH_ENCODING_ERROR = 1220,
    XML_XPATH_INVALID_CHAR_ERROR = 1221,
    XML_TREE_INVALID_HEX = 1300,
    XML_TREE_INVALID_DEC = 1301,
    XML_TREE_UNTERMINATED_ENTITY = 1302,
    XML_TREE_NOT_UTF8 = 1303,
    XML_SAVE_NOT_UTF8 = 1400,
    XML_SAVE_CHAR_INVALID = 1401,
    XML_SAVE_NO_DOCTYPE = 1402,
    XML_SAVE_UNKNOWN_ENCODING = 1403,
    XML_REGEXP_COMPILE_ERROR = 1450,
    XML_IO_UNKNOWN = 1500,
    XML_IO_EACCES = 1501,
    XML_IO_EAGAIN = 1502,
    XML_IO_EBADF = 1503,
    XML_IO_EBADMSG = 1504,
    XML_IO_EBUSY = 1505,
    XML_IO_ECANCELED = 1506,
    XML_IO_ECHILD = 1507,
    XML_IO_EDEADLK = 1508,
    XML_IO_EDOM = 1509,
    XML_IO_EEXIST = 1510,
    XML_IO_EFAULT = 1511,
    XML_IO_EFBIG = 1512,
    XML_IO_EINPROGRESS = 1513,
    XML_IO_EINTR = 1514,
    XML_IO_EINVAL = 1515,
    XML_IO_EIO = 1516,
    XML_IO_EISDIR = 1517,
    XML_IO_EMFILE = 1518,
    XML_IO_EMLINK = 1519,
    XML_IO_EMSGSIZE = 1520,
    XML_IO_ENAMETOOLONG = 1521,
    XML_IO_ENFILE = 1522,
    XML_IO_ENODEV = 1523,
    XML_IO_ENOENT = 1524,
    XML_IO_ENOEXEC = 1525,
    XML_IO_ENOLCK = 1526,
    XML_IO_ENOMEM = 1527,
    XML_IO_ENOSPC = 1528,
    XML_IO_ENOSYS = 1529,
    XML_IO_ENOTDIR = 1530,
    XML_IO_ENOTEMPTY = 1531,
    XML_IO_ENOTSUP = 1532,
    XML_IO_ENOTTY = 1533,
    XML_IO_ENXIO = 1534,
    XML_IO_EPERM = 1535,
    XML_IO_EPIPE = 1536,
    XML_IO_ERANGE = 1537,
    XML_IO_EROFS = 1538,
    XML_IO_ESPIPE = 1539,
    XML_IO_ESRCH = 1540,
    XML_IO_ETIMEDOUT = 1541,
    XML_IO_EXDEV = 1542,
    XML_IO_NETWORK_ATTEMPT = 1543,
    XML_IO_ENCODER = 1544,
    XML_IO_FLUSH = 1545,
    XML_IO_WRITE = 1546,
    XML_IO_NO_INPUT = 1547,
    XML_IO_BUFFER_FULL = 1548,
    XML_IO_LOAD_ERROR = 1549,
    XML_IO_ENOTSOCK = 1550,
    XML_IO_EISCONN = 1551,
    XML_IO_ECONNREFUSED = 1552,
    XML_IO_ENETUNREACH = 1553,
    XML_IO_EADDRINUSE = 1554,
    XML_IO_EALREADY = 1555,
    XML_IO_EAFNOSUPPORT = 1556,
    XML_XINCLUDE_RECURSION = 1600,
    XML_XINCLUDE_PARSE_VALUE = 1601,
    XML_XINCLUDE_ENTITY_DEF_MISMATCH = 1602,
    XML_XINCLUDE_NO_HREF = 1603,
    XML_XINCLUDE_NO_FALLBACK = 1604,
    XML_XINCLUDE_HREF_URI = 1605,
    XML_XINCLUDE_TEXT_FRAGMENT = 1606,
    XML_XINCLUDE_TEXT_DOCUMENT = 1607,
    XML_XINCLUDE_INVALID_CHAR = 1608,
    XML_XINCLUDE_BUILD_FAILED = 1609,
    XML_XINCLUDE_UNKNOWN_ENCODING = 1610,
    XML_XINCLUDE_MULTIPLE_ROOT = 1611,
    XML_XINCLUDE_XPTR_FAILED = 1612,
    XML_XINCLUDE_XPTR_RESULT = 1613,
    XML_XINCLUDE_INCLUDE_IN_INCLUDE = 1614,
    XML_XINCLUDE_FALLBACKS_IN_INCLUDE = 1615,
    XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE = 1616,
    XML_XINCLUDE_DEPRECATED_NS = 1617,
    XML_XINCLUDE_FRAGMENT_ID = 1618,
    XML_CATALOG_MISSING_ATTR = 1650,
    XML_CATALOG_ENTRY_BROKEN = 1651,
    XML_CATALOG_PREFER_VALUE = 1652,
    XML_CATALOG_NOT_CATALOG = 1653,
    XML_CATALOG_RECURSION = 1654,
    XML_SCHEMAP_PREFIX_UNDEFINED = 1700,
    XML_SCHEMAP_ATTRFORMDEFAULT_VALUE = 1701,
    XML_SCHEMAP_ATTRGRP_NONAME_NOREF = 1702,
    XML_SCHEMAP_ATTR_NONAME_NOREF = 1703,
    XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF = 1704,
    XML_SCHEMAP_ELEMFORMDEFAULT_VALUE = 1705,
    XML_SCHEMAP_ELEM_NONAME_NOREF = 1706,
    XML_SCHEMAP_EXTENSION_NO_BASE = 1707,
    XML_SCHEMAP_FACET_NO_VALUE = 1708,
    XML_SCHEMAP_FAILED_BUILD_IMPORT = 1709,
    XML_SCHEMAP_GROUP_NONAME_NOREF = 1710,
    XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI = 1711,
    XML_SCHEMAP_IMPORT_REDEFINE_NSNAME = 1712,
    XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI = 1713,
    XML_SCHEMAP_INVALID_BOOLEAN = 1714,
    XML_SCHEMAP_INVALID_ENUM = 1715,
    XML_SCHEMAP_INVALID_FACET = 1716,
    XML_SCHEMAP_INVALID_FACET_VALUE = 1717,
    XML_SCHEMAP_INVALID_MAXOCCURS = 1718,
    XML_SCHEMAP_INVALID_MINOCCURS = 1719,
    XML_SCHEMAP_INVALID_REF_AND_SUBTYPE = 1720,
    XML_SCHEMAP_INVALID_WHITE_SPACE = 1721,
    XML_SCHEMAP_NOATTR_NOREF = 1722,
    XML_SCHEMAP_NOTATION_NO_NAME = 1723,
    XML_SCHEMAP_NOTYPE_NOREF = 1724,
    XML_SCHEMAP_REF_AND_SUBTYPE = 1725,
    XML_SCHEMAP_RESTRICTION_NONAME_NOREF = 1726,
    XML_SCHEMAP_SIMPLETYPE_NONAME = 1727,
    XML_SCHEMAP_TYPE_AND_SUBTYPE = 1728,
    XML_SCHEMAP_UNKNOWN_ALL_CHILD = 1729,
    XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD = 1730,
    XML_SCHEMAP_UNKNOWN_ATTR_CHILD = 1731,
    XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD = 1732,
    XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP = 1733,
    XML_SCHEMAP_UNKNOWN_BASE_TYPE = 1734,
    XML_SCHEMAP_UNKNOWN_CHOICE_CHILD = 1735,
    XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD = 1736,
    XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD = 1737,
    XML_SCHEMAP_UNKNOWN_ELEM_CHILD = 1738,
    XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD = 1739,
    XML_SCHEMAP_UNKNOWN_FACET_CHILD = 1740,
    XML_SCHEMAP_UNKNOWN_FACET_TYPE = 1741,
    XML_SCHEMAP_UNKNOWN_GROUP_CHILD = 1742,
    XML_SCHEMAP_UNKNOWN_IMPORT_CHILD = 1743,
    XML_SCHEMAP_UNKNOWN_LIST_CHILD = 1744,
    XML_SCHEMAP_UNKNOWN_NOTATION_CHILD = 1745,
    XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD = 1746,
    XML_SCHEMAP_UNKNOWN_REF = 1747,
    XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD = 1748,
    XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD = 1749,
    XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD = 1750,
    XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD = 1751,
    XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD = 1752,
    XML_SCHEMAP_UNKNOWN_TYPE = 1753,
    XML_SCHEMAP_UNKNOWN_UNION_CHILD = 1754,
    XML_SCHEMAP_ELEM_DEFAULT_FIXED = 1755,
    XML_SCHEMAP_REGEXP_INVALID = 1756,
    XML_SCHEMAP_FAILED_LOAD = 1757,
    XML_SCHEMAP_NOTHING_TO_PARSE = 1758,
    XML_SCHEMAP_NOROOT = 1759,
    XML_SCHEMAP_REDEFINED_GROUP = 1760,
    XML_SCHEMAP_REDEFINED_TYPE = 1761,
    XML_SCHEMAP_REDEFINED_ELEMENT = 1762,
    XML_SCHEMAP_REDEFINED_ATTRGROUP = 1763,
    XML_SCHEMAP_REDEFINED_ATTR = 1764,
    XML_SCHEMAP_REDEFINED_NOTATION = 1765,
    XML_SCHEMAP_FAILED_PARSE = 1766,
    XML_SCHEMAP_UNKNOWN_PREFIX = 1767,
    XML_SCHEMAP_DEF_AND_PREFIX = 1768,
    XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD = 1769,
    XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI = 1770,
    XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI = 1771,
    XML_SCHEMAP_NOT_SCHEMA = 1772,
    XML_SCHEMAP_UNKNOWN_MEMBER_TYPE = 1773,
    XML_SCHEMAP_INVALID_ATTR_USE = 1774,
    XML_SCHEMAP_RECURSIVE = 1775,
    XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE = 1776,
    XML_SCHEMAP_INVALID_ATTR_COMBINATION = 1777,
    XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION = 1778,
    XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD = 1779,
    XML_SCHEMAP_INVALID_ATTR_NAME = 1780,
    XML_SCHEMAP_REF_AND_CONTENT = 1781,
    XML_SCHEMAP_CT_PROPS_CORRECT_1 = 1782,
    XML_SCHEMAP_CT_PROPS_CORRECT_2 = 1783,
    XML_SCHEMAP_CT_PROPS_CORRECT_3 = 1784,
    XML_SCHEMAP_CT_PROPS_CORRECT_4 = 1785,
    XML_SCHEMAP_CT_PROPS_CORRECT_5 = 1786,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1 = 1787,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1 = 1788,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2 = 1789,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2 = 1790,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3 = 1791,
    XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER = 1792,
    XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE = 1793,
    XML_SCHEMAP_UNION_NOT_EXPRESSIBLE = 1794,
    XML_SCHEMAP_SRC_IMPORT_3_1 = 1795,
    XML_SCHEMAP_SRC_IMPORT_3_2 = 1796,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1 = 1797,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2 = 1798,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3 = 1799,
    XML_SCHEMAP_COS_CT_EXTENDS_1_3 = 1800,
    XML_SCHEMAV_NOROOT = 1801,
    XML_SCHEMAV_UNDECLAREDELEM = 1802,
    XML_SCHEMAV_NOTTOPLEVEL = 1803,
    XML_SCHEMAV_MISSING = 1804,
    XML_SCHEMAV_WRONGELEM = 1805,
    XML_SCHEMAV_NOTYPE = 1806,
    XML_SCHEMAV_NOROLLBACK = 1807,
    XML_SCHEMAV_ISABSTRACT = 1808,
    XML_SCHEMAV_NOTEMPTY = 1809,
    XML_SCHEMAV_ELEMCONT = 1810,
    XML_SCHEMAV_HAVEDEFAULT = 1811,
    XML_SCHEMAV_NOTNILLABLE = 1812,
    XML_SCHEMAV_EXTRACONTENT = 1813,
    XML_SCHEMAV_INVALIDATTR = 1814,
    XML_SCHEMAV_INVALIDELEM = 1815,
    XML_SCHEMAV_NOTDETERMINIST = 1816,
    XML_SCHEMAV_CONSTRUCT = 1817,
    XML_SCHEMAV_INTERNAL = 1818,
    XML_SCHEMAV_NOTSIMPLE = 1819,
    XML_SCHEMAV_ATTRUNKNOWN = 1820,
    XML_SCHEMAV_ATTRINVALID = 1821,
    XML_SCHEMAV_VALUE = 1822,
    XML_SCHEMAV_FACET = 1823,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1 = 1824,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2 = 1825,
    XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3 = 1826,
    XML_SCHEMAV_CVC_TYPE_3_1_1 = 1827,
    XML_SCHEMAV_CVC_TYPE_3_1_2 = 1828,
    XML_SCHEMAV_CVC_FACET_VALID = 1829,
    XML_SCHEMAV_CVC_LENGTH_VALID = 1830,
    XML_SCHEMAV_CVC_MINLENGTH_VALID = 1831,
    XML_SCHEMAV_CVC_MAXLENGTH_VALID = 1832,
    XML_SCHEMAV_CVC_MININCLUSIVE_VALID = 1833,
    XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID = 1834,
    XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID = 1835,
    XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID = 1836,
    XML_SCHEMAV_CVC_TOTALDIGITS_VALID = 1837,
    XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID = 1838,
    XML_SCHEMAV_CVC_PATTERN_VALID = 1839,
    XML_SCHEMAV_CVC_ENUMERATION_VALID = 1840,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1 = 1841,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2 = 1842,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3 = 1843,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4 = 1844,
    XML_SCHEMAV_CVC_ELT_1 = 1845,
    XML_SCHEMAV_CVC_ELT_2 = 1846,
    XML_SCHEMAV_CVC_ELT_3_1 = 1847,
    XML_SCHEMAV_CVC_ELT_3_2_1 = 1848,
    XML_SCHEMAV_CVC_ELT_3_2_2 = 1849,
    XML_SCHEMAV_CVC_ELT_4_1 = 1850,
    XML_SCHEMAV_CVC_ELT_4_2 = 1851,
    XML_SCHEMAV_CVC_ELT_4_3 = 1852,
    XML_SCHEMAV_CVC_ELT_5_1_1 = 1853,
    XML_SCHEMAV_CVC_ELT_5_1_2 = 1854,
    XML_SCHEMAV_CVC_ELT_5_2_1 = 1855,
    XML_SCHEMAV_CVC_ELT_5_2_2_1 = 1856,
    XML_SCHEMAV_CVC_ELT_5_2_2_2_1 = 1857,
    XML_SCHEMAV_CVC_ELT_5_2_2_2_2 = 1858,
    XML_SCHEMAV_CVC_ELT_6 = 1859,
    XML_SCHEMAV_CVC_ELT_7 = 1860,
    XML_SCHEMAV_CVC_ATTRIBUTE_1 = 1861,
    XML_SCHEMAV_CVC_ATTRIBUTE_2 = 1862,
    XML_SCHEMAV_CVC_ATTRIBUTE_3 = 1863,
    XML_SCHEMAV_CVC_ATTRIBUTE_4 = 1864,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1 = 1865,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1 = 1866,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2 = 1867,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_4 = 1868,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1 = 1869,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2 = 1870,
    XML_SCHEMAV_ELEMENT_CONTENT = 1871,
    XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING = 1872,
    XML_SCHEMAV_CVC_COMPLEX_TYPE_1 = 1873,
    XML_SCHEMAV_CVC_AU = 1874,
    XML_SCHEMAV_CVC_TYPE_1 = 1875,
    XML_SCHEMAV_CVC_TYPE_2 = 1876,
    XML_SCHEMAV_CVC_IDC = 1877,
    XML_SCHEMAV_CVC_WILDCARD = 1878,
    XML_SCHEMAV_MISC = 1879,
    XML_XPTR_UNKNOWN_SCHEME = 1900,
    XML_XPTR_CHILDSEQ_START = 1901,
    XML_XPTR_EVAL_FAILED = 1902,
    XML_XPTR_EXTRA_OBJECTS = 1903,
    XML_C14N_CREATE_CTXT = 1950,
    XML_C14N_REQUIRES_UTF8 = 1951,
    XML_C14N_CREATE_STACK = 1952,
    XML_C14N_INVALID_NODE = 1953,
    XML_C14N_UNKNOW_NODE = 1954,
    XML_C14N_RELATIVE_NAMESPACE = 1955,
    XML_FTP_PASV_ANSWER = 2000,
    XML_FTP_EPSV_ANSWER = 2001,
    XML_FTP_ACCNT = 2002,
    XML_FTP_URL_SYNTAX = 2003,
    XML_HTTP_URL_SYNTAX = 2020,
    XML_HTTP_USE_IP = 2021,
    XML_HTTP_UNKNOWN_HOST = 2022,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_2 = 3001,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_3 = 3002,
    XML_SCHEMAP_SRC_SIMPLE_TYPE_4 = 3003,
    XML_SCHEMAP_SRC_RESOLVE = 3004,
    XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE = 3005,
    XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE = 3006,
    XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES = 3007,
    XML_SCHEMAP_ST_PROPS_CORRECT_1 = 3008,
    XML_SCHEMAP_ST_PROPS_CORRECT_2 = 3009,
    XML_SCHEMAP_ST_PROPS_CORRECT_3 = 3010,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_1 = 3011,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_2 = 3012,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1 = 3013,
    XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2 = 3014,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_1 = 3015,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1 = 3016,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2 = 3017,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1 = 3018,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2 = 3019,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3 = 3020,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4 = 3021,
    XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5 = 3022,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_1 = 3023,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1 = 3024,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2 = 3025,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2 = 3026,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1 = 3027,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3 = 3028,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4 = 3029,
    XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5 = 3030,
    XML_SCHEMAP_COS_ST_DERIVED_OK_2_1 = 3031,
    XML_SCHEMAP_COS_ST_DERIVED_OK_2_2 = 3032,
    XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED = 3033,
    XML_SCHEMAP_S4S_ELEM_MISSING = 3034,
    XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED = 3035,
    XML_SCHEMAP_S4S_ATTR_MISSING = 3036,
    XML_SCHEMAP_S4S_ATTR_INVALID_VALUE = 3037,
    XML_SCHEMAP_SRC_ELEMENT_1 = 3038,
    XML_SCHEMAP_SRC_ELEMENT_2_1 = 3039,
    XML_SCHEMAP_SRC_ELEMENT_2_2 = 3040,
    XML_SCHEMAP_SRC_ELEMENT_3 = 3041,
    XML_SCHEMAP_P_PROPS_CORRECT_1 = 3042,
    XML_SCHEMAP_P_PROPS_CORRECT_2_1 = 3043,
    XML_SCHEMAP_P_PROPS_CORRECT_2_2 = 3044,
    XML_SCHEMAP_E_PROPS_CORRECT_2 = 3045,
    XML_SCHEMAP_E_PROPS_CORRECT_3 = 3046,
    XML_SCHEMAP_E_PROPS_CORRECT_4 = 3047,
    XML_SCHEMAP_E_PROPS_CORRECT_5 = 3048,
    XML_SCHEMAP_E_PROPS_CORRECT_6 = 3049,
    XML_SCHEMAP_SRC_INCLUDE = 3050,
    XML_SCHEMAP_SRC_ATTRIBUTE_1 = 3051,
    XML_SCHEMAP_SRC_ATTRIBUTE_2 = 3052,
    XML_SCHEMAP_SRC_ATTRIBUTE_3_1 = 3053,
    XML_SCHEMAP_SRC_ATTRIBUTE_3_2 = 3054,
    XML_SCHEMAP_SRC_ATTRIBUTE_4 = 3055,
    XML_SCHEMAP_NO_XMLNS = 3056,
    XML_SCHEMAP_NO_XSI = 3057,
    XML_SCHEMAP_COS_VALID_DEFAULT_1 = 3058,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_1 = 3059,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1 = 3060,
    XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2 = 3061,
    XML_SCHEMAP_CVC_SIMPLE_TYPE = 3062,
    XML_SCHEMAP_COS_CT_EXTENDS_1_1 = 3063,
    XML_SCHEMAP_SRC_IMPORT_1_1 = 3064,
    XML_SCHEMAP_SRC_IMPORT_1_2 = 3065,
    XML_SCHEMAP_SRC_IMPORT_2 = 3066,
    XML_SCHEMAP_SRC_IMPORT_2_1 = 3067,
    XML_SCHEMAP_SRC_IMPORT_2_2 = 3068,
    XML_SCHEMAP_INTERNAL = 3069,
    XML_SCHEMAP_NOT_DETERMINISTIC = 3070,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1 = 3071,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2 = 3072,
    XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3 = 3073,
    XML_SCHEMAP_MG_PROPS_CORRECT_1 = 3074,
    XML_SCHEMAP_MG_PROPS_CORRECT_2 = 3075,
    XML_SCHEMAP_SRC_CT_1 = 3076,
    XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3 = 3077,
    XML_SCHEMAP_AU_PROPS_CORRECT_2 = 3078,
    XML_SCHEMAP_A_PROPS_CORRECT_2 = 3079,
    XML_SCHEMAP_C_PROPS_CORRECT = 3080,
    XML_SCHEMAP_SRC_REDEFINE = 3081,
    XML_SCHEMAP_SRC_IMPORT = 3082,
    XML_SCHEMAP_WARN_SKIP_SCHEMA = 3083,
    XML_SCHEMAP_WARN_UNLOCATED_SCHEMA = 3084,
    XML_SCHEMAP_WARN_ATTR_REDECL_PROH = 3085,
    XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH = 3086,
    XML_SCHEMAP_AG_PROPS_CORRECT = 3087,
    XML_SCHEMAP_COS_CT_EXTENDS_1_2 = 3088,
    XML_SCHEMAP_AU_PROPS_CORRECT = 3089,
    XML_SCHEMAP_A_PROPS_CORRECT_3 = 3090,
    XML_SCHEMAP_COS_ALL_LIMITED = 3091,
    XML_SCHEMATRONV_ASSERT = 4000,
    XML_SCHEMATRONV_REPORT = 4001,
    XML_MODULE_OPEN = 4900,
    XML_MODULE_CLOSE = 4901,
    XML_CHECK_FOUND_ELEMENT = 5000,
    XML_CHECK_FOUND_ATTRIBUTE = 5001,
    XML_CHECK_FOUND_TEXT = 5002,
    XML_CHECK_FOUND_CDATA = 5003,
    XML_CHECK_FOUND_ENTITYREF = 5004,
    XML_CHECK_FOUND_ENTITY = 5005,
    XML_CHECK_FOUND_PI = 5006,
    XML_CHECK_FOUND_COMMENT = 5007,
    XML_CHECK_FOUND_DOCTYPE = 5008,
    XML_CHECK_FOUND_FRAGMENT = 5009,
    XML_CHECK_FOUND_NOTATION = 5010,
    XML_CHECK_UNKNOWN_NODE = 5011,
    XML_CHECK_ENTITY_TYPE = 5012,
    XML_CHECK_NO_PARENT = 5013,
    XML_CHECK_NO_DOC = 5014,
    XML_CHECK_NO_NAME = 5015,
    XML_CHECK_NO_ELEM = 5016,
    XML_CHECK_WRONG_DOC = 5017,
    XML_CHECK_NO_PREV = 5018,
    XML_CHECK_WRONG_PREV = 5019,
    XML_CHECK_NO_NEXT = 5020,
    XML_CHECK_WRONG_NEXT = 5021,
    XML_CHECK_NOT_DTD = 5022,
    XML_CHECK_NOT_ATTR = 5023,
    XML_CHECK_NOT_ATTR_DECL = 5024,
    XML_CHECK_NOT_ELEM_DECL = 5025,
    XML_CHECK_NOT_ENTITY_DECL = 5026,
    XML_CHECK_NOT_NS_DECL = 5027,
    XML_CHECK_NO_HREF = 5028,
    XML_CHECK_WRONG_PARENT = 5029,
    XML_CHECK_NS_SCOPE = 5030,
    XML_CHECK_NS_ANCESTOR = 5031,
    XML_CHECK_NOT_UTF8 = 5032,
    XML_CHECK_NO_DICT = 5033,
    XML_CHECK_NOT_NCNAME = 5034,
    XML_CHECK_OUTSIDE_DICT = 5035,
    XML_CHECK_WRONG_NAME = 5036,
    XML_CHECK_NAME_NOT_NULL = 5037,
    XML_I18N_NO_NAME = 6000,
    XML_I18N_NO_HANDLER = 6001,
    XML_I18N_EXCESS_HANDLER = 6002,
    XML_I18N_CONV_FAILED = 6003,
    XML_I18N_NO_OUTPUT = 6004
} ;
enum __anonenum_xmlErrorDomain_90;
typedef enum __anonenum_xmlErrorDomain_90 xmlErrorDomain;
enum __anonenum_xmlErrorDomain_90 {
    XML_FROM_NONE = 0,
    XML_FROM_PARSER = 1,
    XML_FROM_TREE = 2,
    XML_FROM_NAMESPACE = 3,
    XML_FROM_DTD = 4,
    XML_FROM_HTML = 5,
    XML_FROM_MEMORY = 6,
    XML_FROM_OUTPUT = 7,
    XML_FROM_IO = 8,
    XML_FROM_FTP = 9,
    XML_FROM_HTTP = 10,
    XML_FROM_XINCLUDE = 11,
    XML_FROM_XPATH = 12,
    XML_FROM_XPOINTER = 13,
    XML_FROM_REGEXP = 14,
    XML_FROM_DATATYPE = 15,
    XML_FROM_SCHEMASP = 16,
    XML_FROM_SCHEMASV = 17,
    XML_FROM_RELAXNGP = 18,
    XML_FROM_RELAXNGV = 19,
    XML_FROM_CATALOG = 20,
    XML_FROM_C14N = 21,
    XML_FROM_XSLT = 22,
    XML_FROM_VALID = 23,
    XML_FROM_CHECK = 24,
    XML_FROM_WRITER = 25,
    XML_FROM_MODULE = 26,
    XML_FROM_I18N = 27,
    XML_FROM_SCHEMATRONV = 28
} ;
enum __anonenum_xmlErrorLevel_89;
typedef void (*xmlHashScannerFull)(void *payload , void *data ,
                                   xmlChar const   *name ,
                                   xmlChar const   *name2 ,
                                   xmlChar const   *name3 );
typedef void (*xmlHashScanner)(void *payload , void *data , xmlChar *name );
typedef void *(*xmlHashCopier)(void *payload , xmlChar *name );
typedef void (*xmlHashDeallocator)(void *payload , xmlChar *name );
struct _xmlDOMWrapCtxt {
   void *_private ;
   int type ;
   void *namespaceMap ;
   xmlNsPtr (*getNsForNodeFunc)(xmlDOMWrapCtxtPtr ctxt , xmlNodePtr node ,
                                xmlChar const   *nsName ,
                                xmlChar const   *nsPrefix ) ;
};
typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction)(xmlDOMWrapCtxtPtr ctxt ,
                                                xmlNodePtr node ,
                                                xmlChar const   *nsName ,
                                                xmlChar const   *nsPrefix );
enum __anonenum_xmlDocProperties_88;
typedef enum __anonenum_xmlDocProperties_88 xmlDocProperties;
enum __anonenum_xmlDocProperties_88 {
    XML_DOC_WELLFORMED = 1,
    XML_DOC_NSVALID = 2,
    XML_DOC_OLD10 = 4,
    XML_DOC_DTDVALID = 8,
    XML_DOC_XINCLUDE = 16,
    XML_DOC_USERBUILT = 32,
    XML_DOC_INTERNAL = 64,
    XML_DOC_HTML = 128
} ;
struct _xmlRef {
   struct _xmlRef *next ;
   xmlChar const   *value ;
   xmlAttrPtr attr ;
   xmlChar const   *name ;
   int lineno ;
};
struct _xmlID {
   struct _xmlID *next ;
   xmlChar const   *value ;
   xmlAttrPtr attr ;
   xmlChar const   *name ;
   int lineno ;
   struct _xmlDoc *doc ;
};
struct _xmlDtd {
   void *_private ;
   xmlElementType type ;
   xmlChar const   *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlDoc *parent ;
   struct _xmlNode *next ;
   struct _xmlNode *prev ;
   struct _xmlDoc *doc ;
   void *notations ;
   void *elements ;
   void *attributes ;
   void *entities ;
   xmlChar const   *ExternalID ;
   xmlChar const   *SystemID ;
   void *pentities ;
};
enum __anonenum_xmlElementType_81;
enum __anonenum_xmlElementTypeVal_86 {
    XML_ELEMENT_TYPE_UNDEFINED = 0,
    XML_ELEMENT_TYPE_EMPTY = 1,
    XML_ELEMENT_TYPE_ANY = 2,
    XML_ELEMENT_TYPE_MIXED = 3,
    XML_ELEMENT_TYPE_ELEMENT = 4
} ;
struct _xmlElement {
   void *_private ;
   xmlElementType type ;
   xmlChar const   *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlDtd *parent ;
   struct _xmlNode *next ;
   struct _xmlNode *prev ;
   struct _xmlDoc *doc ;
   xmlElementTypeVal etype ;
   xmlElementContentPtr content ;
   xmlAttributePtr attributes ;
   xmlChar const   *prefix ;
   xmlRegexpPtr contModel ;
};
enum __anonenum_xmlExpNodeType_87;
typedef enum __anonenum_xmlExpNodeType_87 xmlExpNodeType;
enum __anonenum_xmlExpNodeType_87 {
    XML_EXP_EMPTY = 0,
    XML_EXP_FORBID = 1,
    XML_EXP_ATOM = 2,
    XML_EXP_SEQ = 3,
    XML_EXP_OR = 4,
    XML_EXP_COUNT = 5
} ;
typedef void (*xmlRegExecCallbacks)(xmlRegExecCtxtPtr exec ,
                                    xmlChar const   *token , void *transdata ,
                                    void *inputdata );
enum __anonenum_xmlElementContentOccur_85 {
    XML_ELEMENT_CONTENT_ONCE = 1,
    XML_ELEMENT_CONTENT_OPT = 2,
    XML_ELEMENT_CONTENT_MULT = 3,
    XML_ELEMENT_CONTENT_PLUS = 4
} ;
typedef enum __anonenum_xmlElementContentOccur_85 xmlElementContentOccur;
enum __anonenum_xmlElementContentType_84 {
    XML_ELEMENT_CONTENT_PCDATA = 1,
    XML_ELEMENT_CONTENT_ELEMENT = 2,
    XML_ELEMENT_CONTENT_SEQ = 3,
    XML_ELEMENT_CONTENT_OR = 4
} ;
struct _xmlElementContent {
   xmlElementContentType type ;
   xmlElementContentOccur ocur ;
   xmlChar const   *name ;
   struct _xmlElementContent *c1 ;
   struct _xmlElementContent *c2 ;
   struct _xmlElementContent *parent ;
   xmlChar const   *prefix ;
};
enum __anonenum_xmlElementContentOccur_85;
enum __anonenum_xmlAttributeDefault_83 {
    XML_ATTRIBUTE_NONE = 1,
    XML_ATTRIBUTE_REQUIRED = 2,
    XML_ATTRIBUTE_IMPLIED = 3,
    XML_ATTRIBUTE_FIXED = 4
} ;
struct _xmlAttribute {
   void *_private ;
   xmlElementType type ;
   xmlChar const   *name ;
   struct _xmlNode *children ;
   struct _xmlNode *last ;
   struct _xmlDtd *parent ;
   struct _xmlNode *next ;
   struct _xmlNode *prev ;
   struct _xmlDoc *doc ;
   struct _xmlAttribute *nexth ;
   xmlAttributeType atype ;
   xmlAttributeDefault def ;
   xmlChar const   *defaultValue ;
   xmlEnumerationPtr tree ;
   xmlChar const   *prefix ;
   xmlChar const   *elem ;
};
struct _xmlEnumeration {
   struct _xmlEnumeration *next ;
   xmlChar const   *name ;
};
struct _xmlNotation {
   xmlChar const   *name ;
   xmlChar const   *PublicID ;
   xmlChar const   *SystemID ;
};
struct _xmlBuffer {
   xmlChar *content ;
   unsigned int use ;
   unsigned int size ;
   xmlBufferAllocationScheme alloc ;
   xmlChar *contentIO ;
};
struct timespec {
   __time_t tv_sec ;
   long tv_nsec ;
};
struct itimerspec {
   struct timespec it_interval ;
   struct timespec it_value ;
};
struct tm {
   int tm_sec ;
   int tm_min ;
   int tm_hour ;
   int tm_mday ;
   int tm_mon ;
   int tm_year ;
   int tm_wday ;
   int tm_yday ;
   int tm_isdst ;
   long tm_gmtoff ;
   char const   *tm_zone ;
};
struct _zend_constant {
   zval value ;
   int flags ;
   char *name ;
   uint name_len ;
   int module_number ;
};
struct _cwd_state {
   char *cwd ;
   int cwd_length ;
};
struct _virtual_cwd_globals {
   cwd_state cwd ;
   long realpath_cache_size ;
   long realpath_cache_size_limit ;
   long realpath_cache_ttl ;
   realpath_cache_bucket *realpath_cache[1024] ;
};
struct _realpath_cache_bucket {
   unsigned long key ;
   char *path ;
   int path_len ;
   char *realpath ;
   int realpath_len ;
   int is_dir ;
   time_t expires ;
   struct _realpath_cache_bucket *next ;
};
typedef int (*verify_path_func)(cwd_state const   * );
enum __anonenum_79 {
    DT_UNKNOWN = 0,
    DT_FIFO = 1,
    DT_CHR = 2,
    DT_DIR = 4,
    DT_BLK = 6,
    DT_REG = 8,
    DT_LNK = 10,
    DT_SOCK = 12,
    DT_WHT = 14
} ;
enum __anonenum_79;
typedef __u_quad_t __ino64_t;
struct dirent64 {
   __ino64_t d_ino ;
   __off64_t d_off ;
   unsigned short d_reclen ;
   unsigned char d_type ;
   char d_name[256] ;
};
typedef unsigned long __ino_t;
struct dirent {
   __ino_t d_ino ;
   __off_t d_off ;
   unsigned short d_reclen ;
   unsigned char d_type ;
   char d_name[256] ;
};
struct utimbuf {
   __time_t actime ;
   __time_t modtime ;
};
struct _zend_ini_parser_param;
typedef struct _zend_ini_parser_param zend_ini_parser_param;
struct _zend_ini_parser_param {
   void (*ini_parser_cb)(zval *arg1 , zval *arg2 , zval *arg3 ,
                         int callback_type , void *arg ) ;
   void *arg ;
};
typedef void (*zend_ini_parser_cb_t)(zval *arg1 , zval *arg2 , zval *arg3 ,
                                     int callback_type , void *arg );
struct _zend_ini_entry {
   int module_number ;
   int modifiable ;
   char *name ;
   uint name_length ;
   int (*on_modify)(zend_ini_entry *entry , char *new_value ,
                    uint new_value_length , void *mh_arg1 , void *mh_arg2 ,
                    void *mh_arg3 , int stage ) ;
   void *mh_arg1 ;
   void *mh_arg2 ;
   void *mh_arg3 ;
   char *value ;
   uint value_length ;
   char *orig_value ;
   uint orig_value_length ;
   int orig_modifiable ;
   int modified ;
   void (*displayer)(zend_ini_entry *ini_entry , int type ) ;
};
struct _zend_llist {
   zend_llist_element *head ;
   zend_llist_element *tail ;
   size_t count ;
   size_t size ;
   void (*dtor)(void * ) ;
   unsigned char persistent ;
   zend_llist_element *traverse_ptr ;
};
struct _arg_separators {
   char *output ;
   char *input ;
};
typedef struct _arg_separators arg_separators;
struct _php_core_globals {
   zend_bool magic_quotes_gpc ;
   zend_bool magic_quotes_runtime ;
   zend_bool magic_quotes_sybase ;
   zend_bool implicit_flush ;
   long output_buffering ;
   zend_bool sql_safe_mode ;
   zend_bool enable_dl ;
   char *output_handler ;
   char *unserialize_callback_func ;
   long serialize_precision ;
   long memory_limit ;
   long max_input_time ;
   zend_bool track_errors ;
   zend_bool display_errors ;
   zend_bool display_startup_errors ;
   zend_bool log_errors ;
   long log_errors_max_len ;
   zend_bool ignore_repeated_errors ;
   zend_bool ignore_repeated_source ;
   zend_bool report_memleaks ;
   char *error_log ;
   char *doc_root ;
   char *user_dir ;
   char *include_path ;
   char *open_basedir ;
   char *extension_dir ;
   char *upload_tmp_dir ;
   long upload_max_filesize ;
   char *error_append_string ;
   char *error_prepend_string ;
   char *auto_prepend_file ;
   char *auto_append_file ;
   arg_separators arg_separator ;
   char *variables_order ;
   HashTable rfc1867_protected_variables ;
   short connection_status ;
   short ignore_user_abort ;
   unsigned char header_is_being_sent ;
   zend_llist tick_functions ;
   zval *http_globals[6] ;
   zend_bool expose_php ;
   zend_bool register_argc_argv ;
   zend_bool auto_globals_jit ;
   char *docref_root ;
   char *docref_ext ;
   zend_bool html_errors ;
   zend_bool xmlrpc_errors ;
   long xmlrpc_error_number ;
   zend_bool activated_auto_globals[8] ;
   zend_bool modules_activated ;
   zend_bool file_uploads ;
   zend_bool during_request_startup ;
   zend_bool allow_url_fopen ;
   zend_bool enable_post_data_reading ;
   zend_bool always_populate_raw_post_data ;
   zend_bool report_zend_debug ;
   int last_error_type ;
   char *last_error_message ;
   char *last_error_file ;
   int last_error_lineno ;
   char *disable_functions ;
   char *disable_classes ;
   zend_bool allow_url_include ;
   zend_bool exit_on_timeout ;
   long max_input_nesting_level ;
   zend_bool in_user_include ;
   char *user_ini_filename ;
   long user_ini_cache_ttl ;
   char *request_order ;
   zend_bool mail_x_header ;
   char *mail_log ;
   zend_bool in_error_log ;
};
struct _arg_separators;
struct _php_tick_function_entry;
typedef struct _php_core_globals php_core_globals;
struct __anonstruct_php_stream_mmap_range_78;
typedef struct __anonstruct_php_stream_mmap_range_78 php_stream_mmap_range;
enum __anonenum_php_stream_mmap_access_t_77 {
    PHP_STREAM_MAP_MODE_READONLY = 0,
    PHP_STREAM_MAP_MODE_READWRITE = 1,
    PHP_STREAM_MAP_MODE_SHARED_READONLY = 2,
    PHP_STREAM_MAP_MODE_SHARED_READWRITE = 3
} ;
typedef enum __anonenum_php_stream_mmap_access_t_77 php_stream_mmap_access_t;
struct __anonstruct_php_stream_mmap_range_78 {
   size_t offset ;
   size_t length ;
   php_stream_mmap_access_t mode ;
   char *mapped ;
};
enum __anonenum_php_stream_mmap_access_t_77;
enum __anonenum_php_stream_mmap_operation_t_76 {
    PHP_STREAM_MMAP_SUPPORTED = 0,
    PHP_STREAM_MMAP_MAP_RANGE = 1,
    PHP_STREAM_MMAP_UNMAP = 2
} ;
struct _php_stream_xport_crypto_param;
typedef struct _php_stream_xport_crypto_param php_stream_xport_crypto_param;
struct __anonstruct_outputs_75 {
   int returncode ;
};
enum __anonenum_php_stream_xport_crypt_method_t_72 {
    STREAM_CRYPTO_METHOD_SSLv2_CLIENT = 0,
    STREAM_CRYPTO_METHOD_SSLv3_CLIENT = 1,
    STREAM_CRYPTO_METHOD_SSLv23_CLIENT = 2,
    STREAM_CRYPTO_METHOD_TLS_CLIENT = 3,
    STREAM_CRYPTO_METHOD_SSLv2_SERVER = 4,
    STREAM_CRYPTO_METHOD_SSLv3_SERVER = 5,
    STREAM_CRYPTO_METHOD_SSLv23_SERVER = 6,
    STREAM_CRYPTO_METHOD_TLS_SERVER = 7
} ;
struct __anonstruct_inputs_74 {
   int activate ;
   php_stream_xport_crypt_method_t method ;
   php_stream *session ;
};
enum __anonenum_op_73 {
    STREAM_XPORT_CRYPTO_OP_SETUP = 0,
    STREAM_XPORT_CRYPTO_OP_ENABLE = 1
} ;
struct _php_stream_xport_crypto_param {
   enum __anonenum_op_73 op ;
   struct __anonstruct_inputs_74 inputs ;
   struct __anonstruct_outputs_75 outputs ;
};
struct __anonstruct_outputs_75;
struct __anonstruct_inputs_74;
enum __anonenum_op_73;
struct _php_stream_xport_param;
typedef struct _php_stream_xport_param php_stream_xport_param;
struct __anonstruct_outputs_71 {
   php_stream *client ;
   int returncode ;
   struct sockaddr *addr ;
   socklen_t addrlen ;
   char *textaddr ;
   long textaddrlen ;
   char *error_text ;
   int error_code ;
};
struct __anonstruct_inputs_70 {
   char *name ;
   long namelen ;
   int backlog ;
   struct timeval *timeout ;
   struct sockaddr *addr ;
   socklen_t addrlen ;
   char *buf ;
   size_t buflen ;
   long flags ;
};
enum __anonenum_op_69 {
    STREAM_XPORT_OP_BIND = 0,
    STREAM_XPORT_OP_CONNECT = 1,
    STREAM_XPORT_OP_LISTEN = 2,
    STREAM_XPORT_OP_ACCEPT = 3,
    STREAM_XPORT_OP_CONNECT_ASYNC = 4,
    STREAM_XPORT_OP_GET_NAME = 5,
    STREAM_XPORT_OP_GET_PEER_NAME = 6,
    STREAM_XPORT_OP_RECV = 7,
    STREAM_XPORT_OP_SEND = 8,
    STREAM_XPORT_OP_SHUTDOWN = 9
} ;
struct _php_stream_xport_param {
   enum __anonenum_op_69 op ;
   unsigned int want_addr : 1 ;
   unsigned int want_textaddr : 1 ;
   unsigned int want_errortext : 1 ;
   unsigned int how : 2 ;
   struct __anonstruct_inputs_70 inputs ;
   struct __anonstruct_outputs_71 outputs ;
};
struct __anonstruct_outputs_71;
struct __anonstruct_inputs_70;
enum __anonenum_op_69;
enum __anonenum_stream_shutdown_t_68 {
    STREAM_SHUT_RD = 0,
    STREAM_SHUT_WR = 1,
    STREAM_SHUT_RDWR = 2
} ;
enum php_stream_xport_send_recv_flags {
    STREAM_OOB = 1,
    STREAM_PEEK = 2
} ;
enum php_stream_xport_send_recv_flags;
union __anonunion___CONST_SOCKADDR_ARG_67;
typedef union __anonunion___CONST_SOCKADDR_ARG_67  __attribute__((__transparent_union__)) __CONST_SOCKADDR_ARG;
struct sockaddr_x25;
struct sockaddr_un;
struct sockaddr_ns;
struct sockaddr_iso;
struct sockaddr_ipx;
struct sockaddr_inarp;
struct sockaddr_in6;
struct sockaddr_in;
struct sockaddr_eon;
struct sockaddr_dl;
struct sockaddr_ax25;
struct sockaddr_at;
union __anonunion___CONST_SOCKADDR_ARG_67 {
   struct sockaddr  const  * __restrict  __sockaddr__ ;
   struct sockaddr_at  const  * __restrict  __sockaddr_at__ ;
   struct sockaddr_ax25  const  * __restrict  __sockaddr_ax25__ ;
   struct sockaddr_dl  const  * __restrict  __sockaddr_dl__ ;
   struct sockaddr_eon  const  * __restrict  __sockaddr_eon__ ;
   struct sockaddr_in  const  * __restrict  __sockaddr_in__ ;
   struct sockaddr_in6  const  * __restrict  __sockaddr_in6__ ;
   struct sockaddr_inarp  const  * __restrict  __sockaddr_inarp__ ;
   struct sockaddr_ipx  const  * __restrict  __sockaddr_ipx__ ;
   struct sockaddr_iso  const  * __restrict  __sockaddr_iso__ ;
   struct sockaddr_ns  const  * __restrict  __sockaddr_ns__ ;
   struct sockaddr_un  const  * __restrict  __sockaddr_un__ ;
   struct sockaddr_x25  const  * __restrict  __sockaddr_x25__ ;
};
union __anonunion___SOCKADDR_ARG_66;
typedef union __anonunion___SOCKADDR_ARG_66  __attribute__((__transparent_union__)) __SOCKADDR_ARG;
union __anonunion___SOCKADDR_ARG_66 {
   struct sockaddr * __restrict  __sockaddr__ ;
   struct sockaddr_at * __restrict  __sockaddr_at__ ;
   struct sockaddr_ax25 * __restrict  __sockaddr_ax25__ ;
   struct sockaddr_dl * __restrict  __sockaddr_dl__ ;
   struct sockaddr_eon * __restrict  __sockaddr_eon__ ;
   struct sockaddr_in * __restrict  __sockaddr_in__ ;
   struct sockaddr_in6 * __restrict  __sockaddr_in6__ ;
   struct sockaddr_inarp * __restrict  __sockaddr_inarp__ ;
   struct sockaddr_ipx * __restrict  __sockaddr_ipx__ ;
   struct sockaddr_iso * __restrict  __sockaddr_iso__ ;
   struct sockaddr_ns * __restrict  __sockaddr_ns__ ;
   struct sockaddr_un * __restrict  __sockaddr_un__ ;
   struct sockaddr_x25 * __restrict  __sockaddr_x25__ ;
};
enum __anonenum_65 {
    SHUT_RD = 0,
    SHUT_WR = 1,
    SHUT_RDWR = 2
} ;
enum __anonenum_65;
struct osockaddr {
   unsigned short sa_family ;
   unsigned char sa_data[14] ;
};
struct osockaddr;
struct linger {
   int l_onoff ;
   int l_linger ;
};
struct linger;
struct ucred {
   pid_t pid ;
   uid_t uid ;
   gid_t gid ;
};
struct ucred;
enum __anonenum_64 {
    SCM_RIGHTS = 1,
    SCM_CREDENTIALS = 2
} ;
enum __anonenum_64;
struct mmsghdr {
   struct msghdr msg_hdr ;
   unsigned int msg_len ;
};
enum __anonenum_63 {
    MSG_OOB = 1,
    MSG_PEEK = 2,
    MSG_DONTROUTE = 4,
    MSG_TRYHARD = 4,
    MSG_CTRUNC = 8,
    MSG_PROXY = 16,
    MSG_TRUNC = 32,
    MSG_DONTWAIT = 64,
    MSG_EOR = 128,
    MSG_WAITALL = 256,
    MSG_FIN = 512,
    MSG_SYN = 1024,
    MSG_CONFIRM = 2048,
    MSG_RST = 4096,
    MSG_ERRQUEUE = 8192,
    MSG_NOSIGNAL = 16384,
    MSG_MORE = 32768,
    MSG_WAITFORONE = 65536,
    MSG_CMSG_CLOEXEC = 1073741824
} ;
enum __anonenum_63;
typedef unsigned short sa_family_t;
struct sockaddr_storage {
   sa_family_t ss_family ;
   unsigned long __ss_align ;
   char __ss_padding[128U - 2U * sizeof(unsigned long )] ;
};
struct sockaddr_storage;
struct sockaddr {
   sa_family_t sa_family ;
   char sa_data[14] ;
};
enum __socket_type {
    SOCK_STREAM = 1,
    SOCK_DGRAM = 2,
    SOCK_RAW = 3,
    SOCK_RDM = 4,
    SOCK_SEQPACKET = 5,
    SOCK_DCCP = 6,
    SOCK_PACKET = 10,
    SOCK_CLOEXEC = 524288,
    SOCK_NONBLOCK = 2048
} ;
enum __socket_type;
struct iovec {
   void *iov_base ;
   size_t iov_len ;
};
struct _php_stream_filter_chain {
   php_stream_filter *head ;
   php_stream_filter *tail ;
   php_stream *stream ;
};
struct _php_stream {
   php_stream_ops *ops ;
   void *abstract ;
   php_stream_filter_chain readfilters ;
   php_stream_filter_chain writefilters ;
   php_stream_wrapper *wrapper ;
   void *wrapperthis ;
   zval *wrapperdata ;
   int fgetss_state ;
   int is_persistent ;
   char mode[16] ;
   int rsrc_id ;
   int in_free ;
   int fclose_stdiocast ;
   FILE *stdiocast ;
   char *orig_path ;
   php_stream_context *context ;
   int flags ;
   off_t position ;
   unsigned char *readbuf ;
   size_t readbuflen ;
   off_t readpos ;
   off_t writepos ;
   size_t chunk_size ;
   int eof ;
   struct _php_stream *enclosing_stream ;
};
struct _php_stream_wrapper {
   php_stream_wrapper_ops *wops ;
   void *abstract ;
   int is_url ;
   int err_count ;
   char **err_stack ;
};
struct _php_stream_wrapper_ops {
   php_stream *(*stream_opener)(php_stream_wrapper *wrapper , char *filename ,
                                char *mode , int options , char **opened_path ,
                                php_stream_context *context ) ;
   int (*stream_closer)(php_stream_wrapper *wrapper , php_stream *stream ) ;
   int (*stream_stat)(php_stream_wrapper *wrapper , php_stream *stream ,
                      php_stream_statbuf *ssb ) ;
   int (*url_stat)(php_stream_wrapper *wrapper , char *url , int flags ,
                   php_stream_statbuf *ssb , php_stream_context *context ) ;
   php_stream *(*dir_opener)(php_stream_wrapper *wrapper , char *filename ,
                             char *mode , int options , char **opened_path ,
                             php_stream_context *context ) ;
   char const   *label ;
   int (*unlink)(php_stream_wrapper *wrapper , char *url , int options ,
                 php_stream_context *context ) ;
   int (*rename)(php_stream_wrapper *wrapper , char *url_from , char *url_to ,
                 int options , php_stream_context *context ) ;
   int (*stream_mkdir)(php_stream_wrapper *wrapper , char *url , int mode ,
                       int options , php_stream_context *context ) ;
   int (*stream_rmdir)(php_stream_wrapper *wrapper , char *url , int options ,
                       php_stream_context *context ) ;
};
struct _php_stream_ops {
   size_t (*write)(php_stream *stream , char const   *buf , size_t count ) ;
   size_t (*read)(php_stream *stream , char *buf , size_t count ) ;
   int (*close)(php_stream *stream , int close_handle ) ;
   int (*flush)(php_stream *stream ) ;
   char const   *label ;
   int (*seek)(php_stream *stream , off_t offset , int whence ,
               off_t *newoffset ) ;
   int (*cast)(php_stream *stream , int castas , void **ret ) ;
   int (*stat)(php_stream *stream , php_stream_statbuf *ssb ) ;
   int (*set_option)(php_stream *stream , int option , int value ,
                     void *ptrparam ) ;
};
struct _php_stream_dirent {
   char d_name[4096] ;
};
typedef long __blkcnt_t;
typedef long __blksize_t;
typedef unsigned int __nlink_t;
struct stat {
   __dev_t st_dev ;
   unsigned short __pad1 ;
   __ino_t st_ino ;
   __mode_t st_mode ;
   __nlink_t st_nlink ;
   __uid_t st_uid ;
   __gid_t st_gid ;
   __dev_t st_rdev ;
   unsigned short __pad2 ;
   __off_t st_size ;
   __blksize_t st_blksize ;
   __blkcnt_t st_blocks ;
   struct timespec st_atim ;
   struct timespec st_mtim ;
   struct timespec st_ctim ;
   unsigned long __unused4 ;
   unsigned long __unused5 ;
};
struct _php_stream_statbuf {
   struct stat sb ;
};
struct _php_stream_filter_factory {
   php_stream_filter *(*create_filter)(char const   *filtername ,
                                       zval *filterparams , int persistent ) ;
};
struct _php_stream_bucket_brigade {
   php_stream_bucket *head ;
   php_stream_bucket *tail ;
};
struct _php_stream_filter {
   php_stream_filter_ops *fops ;
   void *abstract ;
   php_stream_filter *next ;
   php_stream_filter *prev ;
   int is_persistent ;
   php_stream_filter_chain *chain ;
   php_stream_bucket_brigade buffer ;
   int rsrc_id ;
};
enum __anonenum_php_stream_filter_status_t_62 {
    PSFS_ERR_FATAL = 0,
    PSFS_FEED_ME = 1,
    PSFS_PASS_ON = 2
} ;
typedef enum __anonenum_php_stream_filter_status_t_62 php_stream_filter_status_t;
struct _php_stream_filter_ops {
   php_stream_filter_status_t (*filter)(php_stream *stream ,
                                        php_stream_filter *thisfilter ,
                                        php_stream_bucket_brigade *buckets_in ,
                                        php_stream_bucket_brigade *buckets_out ,
                                        size_t *bytes_consumed , int flags ) ;
   void (*dtor)(php_stream_filter *thisfilter ) ;
   char const   *label ;
};
enum __anonenum_php_stream_filter_status_t_62;
struct _php_stream_bucket {
   php_stream_bucket *next ;
   php_stream_bucket *prev ;
   php_stream_bucket_brigade *brigade ;
   char *buf ;
   size_t buflen ;
   int own_buf ;
   int is_persistent ;
   int refcount ;
};
struct _php_stream_context {
   php_stream_notifier *notifier ;
   zval *options ;
   zval *links ;
   int rsrc_id ;
};
struct _php_stream_notifier {
   void (*func)(php_stream_context *context , int notifycode , int severity ,
                char *xmsg , int xcode , size_t bytes_sofar , size_t bytes_max ,
                void *ptr ) ;
   void (*dtor)(php_stream_notifier *notifier ) ;
   void *ptr ;
   int mask ;
   size_t progress ;
   size_t progress_max ;
};
typedef void (*php_stream_notification_func)(php_stream_context *context ,
                                             int notifycode , int severity ,
                                             char *xmsg , int xcode ,
                                             size_t bytes_sofar ,
                                             size_t bytes_max , void *ptr );
typedef __quad_t __blkcnt64_t;
struct stat64 {
   __dev_t st_dev ;
   unsigned int __pad1 ;
   __ino_t __st_ino ;
   __mode_t st_mode ;
   __nlink_t st_nlink ;
   __uid_t st_uid ;
   __gid_t st_gid ;
   __dev_t st_rdev ;
   unsigned int __pad2 ;
   __off64_t st_size ;
   __blksize_t st_blksize ;
   __blkcnt64_t st_blocks ;
   struct timespec st_atim ;
   struct timespec st_mtim ;
   struct timespec st_ctim ;
   __ino64_t st_ino ;
};
typedef long __suseconds_t;
struct timeval {
   __time_t tv_sec ;
   __suseconds_t tv_usec ;
};
struct itimerval {
   struct timeval it_interval ;
   struct timeval it_value ;
};
enum __itimer_which {
    ITIMER_REAL = 0,
    ITIMER_VIRTUAL = 1,
    ITIMER_PROF = 2
} ;
struct timezone {
   int tz_minuteswest ;
   int tz_dsttime ;
};
struct _zend_output_globals;
typedef struct _zend_output_globals zend_output_globals;
struct _zend_output_globals {
   int flags ;
   zend_stack handlers ;
   php_output_handler *active ;
   php_output_handler *running ;
   char *output_start_filename ;
   int output_start_lineno ;
};
struct _php_output_handler_user_func_t;
typedef struct _php_output_handler_user_func_t php_output_handler_user_func_t;
union __anonunion_func_61 {
   php_output_handler_user_func_t *user ;
   int (*internal)(void **handler_context , php_output_context *output_context ) ;
};
struct _php_output_buffer {
   char *data ;
   size_t size ;
   size_t used ;
   uint free : 1 ;
   uint _res : 31 ;
};
typedef struct _php_output_buffer php_output_buffer;
struct _php_output_handler {
   char *name ;
   size_t name_len ;
   int flags ;
   int level ;
   size_t size ;
   php_output_buffer buffer ;
   void *opaq ;
   void (*dtor)(void *opaq ) ;
   union __anonunion_func_61 func ;
};
union __anonunion_func_61;
struct _zend_fcall_info_cache {
   zend_bool initialized ;
   zend_function *function_handler ;
   zend_class_entry *calling_scope ;
   zend_class_entry *called_scope ;
   zval *object_ptr ;
};
struct _zend_fcall_info {
   size_t size ;
   HashTable *function_table ;
   zval *function_name ;
   HashTable *symbol_table ;
   zval **retval_ptr_ptr ;
   zend_uint param_count ;
   zval ***params ;
   zval *object_ptr ;
   zend_bool no_separation ;
};
struct _php_output_handler_user_func_t {
   zend_fcall_info fci ;
   zend_fcall_info_cache fcc ;
   zval *zoh ;
};
typedef int (*php_output_handler_conflict_check_t)(char const   *handler_name ,
                                                   size_t handler_name_len );
typedef void (*php_output_handler_context_dtor_t)(void *opaq );
typedef int (*php_output_handler_context_func_t)(void **handler_context ,
                                                 php_output_context *output_context );
typedef void (*php_output_handler_func_t)(char *output , uint output_len ,
                                          char **handled_output ,
                                          uint *handled_output_len , int mode );
struct _php_output_context {
   int op ;
   php_output_buffer in ;
   php_output_buffer out ;
};
struct _php_output_buffer;
enum _php_output_handler_hook_t {
    PHP_OUTPUT_HANDLER_HOOK_GET_OPAQ = 0,
    PHP_OUTPUT_HANDLER_HOOK_GET_FLAGS = 1,
    PHP_OUTPUT_HANDLER_HOOK_GET_LEVEL = 2,
    PHP_OUTPUT_HANDLER_HOOK_IMMUTABLE = 3,
    PHP_OUTPUT_HANDLER_HOOK_DISABLE = 4,
    PHP_OUTPUT_HANDLER_HOOK_LAST = 5
} ;
enum _php_output_handler_status_t;
typedef enum _php_output_handler_status_t php_output_handler_status_t;
enum _php_output_handler_status_t {
    PHP_OUTPUT_HANDLER_FAILURE = 0,
    PHP_OUTPUT_HANDLER_SUCCESS = 1,
    PHP_OUTPUT_HANDLER_NO_DATA = 2
} ;
enum __anonenum_length_modifier_e_60;
typedef enum __anonenum_length_modifier_e_60 length_modifier_e;
enum __anonenum_length_modifier_e_60 {
    LM_STD = 0,
    LM_INTMAX_T = 1,
    LM_PTRDIFF_T = 2,
    LM_LONG_LONG = 3,
    LM_SIZE_T = 4,
    LM_LONG = 5,
    LM_LONG_DOUBLE = 6
} ;
enum __anonenum_boolean_e_59 {
    NO = 0,
    YES = 1
} ;
struct passwd {
   char *pw_name ;
   char *pw_passwd ;
   __uid_t pw_uid ;
   __gid_t pw_gid ;
   char *pw_gecos ;
   char *pw_dir ;
   char *pw_shell ;
};
enum __anonenum_58 {
    _CS_PATH = 0,
    _CS_V6_WIDTH_RESTRICTED_ENVS = 1,
    _CS_GNU_LIBC_VERSION = 2,
    _CS_GNU_LIBPTHREAD_VERSION = 3,
    _CS_V5_WIDTH_RESTRICTED_ENVS = 4,
    _CS_V7_WIDTH_RESTRICTED_ENVS = 5,
    _CS_LFS_CFLAGS = 1000,
    _CS_LFS_LDFLAGS = 1001,
    _CS_LFS_LIBS = 1002,
    _CS_LFS_LINTFLAGS = 1003,
    _CS_LFS64_CFLAGS = 1004,
    _CS_LFS64_LDFLAGS = 1005,
    _CS_LFS64_LIBS = 1006,
    _CS_LFS64_LINTFLAGS = 1007,
    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
    _CS_XBS5_ILP32_OFF32_LDFLAGS = 1101,
    _CS_XBS5_ILP32_OFF32_LIBS = 1102,
    _CS_XBS5_ILP32_OFF32_LINTFLAGS = 1103,
    _CS_XBS5_ILP32_OFFBIG_CFLAGS = 1104,
    _CS_XBS5_ILP32_OFFBIG_LDFLAGS = 1105,
    _CS_XBS5_ILP32_OFFBIG_LIBS = 1106,
    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 1107,
    _CS_XBS5_LP64_OFF64_CFLAGS = 1108,
    _CS_XBS5_LP64_OFF64_LDFLAGS = 1109,
    _CS_XBS5_LP64_OFF64_LIBS = 1110,
    _CS_XBS5_LP64_OFF64_LINTFLAGS = 1111,
    _CS_XBS5_LPBIG_OFFBIG_CFLAGS = 1112,
    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS = 1113,
    _CS_XBS5_LPBIG_OFFBIG_LIBS = 1114,
    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 1115,
    _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116,
    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117,
    _CS_POSIX_V6_ILP32_OFF32_LIBS = 1118,
    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS = 1119,
    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120,
    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121,
    _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122,
    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123,
    _CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124,
    _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125,
    _CS_POSIX_V6_LP64_OFF64_LIBS = 1126,
    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS = 1127,
    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128,
    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129,
    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130,
    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131,
    _CS_POSIX_V7_ILP32_OFF32_CFLAGS = 1132,
    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS = 1133,
    _CS_POSIX_V7_ILP32_OFF32_LIBS = 1134,
    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS = 1135,
    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS = 1136,
    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS = 1137,
    _CS_POSIX_V7_ILP32_OFFBIG_LIBS = 1138,
    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139,
    _CS_POSIX_V7_LP64_OFF64_CFLAGS = 1140,
    _CS_POSIX_V7_LP64_OFF64_LDFLAGS = 1141,
    _CS_POSIX_V7_LP64_OFF64_LIBS = 1142,
    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS = 1143,
    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS = 1144,
    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS = 1145,
    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS = 1146,
    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147,
    _CS_V6_ENV = 1148,
    _CS_V7_ENV = 1149
} ;
enum __anonenum_58;
enum __anonenum_57 {
    _SC_ARG_MAX = 0,
    _SC_CHILD_MAX = 1,
    _SC_CLK_TCK = 2,
    _SC_NGROUPS_MAX = 3,
    _SC_OPEN_MAX = 4,
    _SC_STREAM_MAX = 5,
    _SC_TZNAME_MAX = 6,
    _SC_JOB_CONTROL = 7,
    _SC_SAVED_IDS = 8,
    _SC_REALTIME_SIGNALS = 9,
    _SC_PRIORITY_SCHEDULING = 10,
    _SC_TIMERS = 11,
    _SC_ASYNCHRONOUS_IO = 12,
    _SC_PRIORITIZED_IO = 13,
    _SC_SYNCHRONIZED_IO = 14,
    _SC_FSYNC = 15,
    _SC_MAPPED_FILES = 16,
    _SC_MEMLOCK = 17,
    _SC_MEMLOCK_RANGE = 18,
    _SC_MEMORY_PROTECTION = 19,
    _SC_MESSAGE_PASSING = 20,
    _SC_SEMAPHORES = 21,
    _SC_SHARED_MEMORY_OBJECTS = 22,
    _SC_AIO_LISTIO_MAX = 23,
    _SC_AIO_MAX = 24,
    _SC_AIO_PRIO_DELTA_MAX = 25,
    _SC_DELAYTIMER_MAX = 26,
    _SC_MQ_OPEN_MAX = 27,
    _SC_MQ_PRIO_MAX = 28,
    _SC_VERSION = 29,
    _SC_PAGESIZE = 30,
    _SC_RTSIG_MAX = 31,
    _SC_SEM_NSEMS_MAX = 32,
    _SC_SEM_VALUE_MAX = 33,
    _SC_SIGQUEUE_MAX = 34,
    _SC_TIMER_MAX = 35,
    _SC_BC_BASE_MAX = 36,
    _SC_BC_DIM_MAX = 37,
    _SC_BC_SCALE_MAX = 38,
    _SC_BC_STRING_MAX = 39,
    _SC_COLL_WEIGHTS_MAX = 40,
    _SC_EQUIV_CLASS_MAX = 41,
    _SC_EXPR_NEST_MAX = 42,
    _SC_LINE_MAX = 43,
    _SC_RE_DUP_MAX = 44,
    _SC_CHARCLASS_NAME_MAX = 45,
    _SC_2_VERSION = 46,
    _SC_2_C_BIND = 47,
    _SC_2_C_DEV = 48,
    _SC_2_FORT_DEV = 49,
    _SC_2_FORT_RUN = 50,
    _SC_2_SW_DEV = 51,
    _SC_2_LOCALEDEF = 52,
    _SC_PII = 53,
    _SC_PII_XTI = 54,
    _SC_PII_SOCKET = 55,
    _SC_PII_INTERNET = 56,
    _SC_PII_OSI = 57,
    _SC_POLL = 58,
    _SC_SELECT = 59,
    _SC_UIO_MAXIOV = 60,
    _SC_IOV_MAX = 60,
    _SC_PII_INTERNET_STREAM = 61,
    _SC_PII_INTERNET_DGRAM = 62,
    _SC_PII_OSI_COTS = 63,
    _SC_PII_OSI_CLTS = 64,
    _SC_PII_OSI_M = 65,
    _SC_T_IOV_MAX = 66,
    _SC_THREADS = 67,
    _SC_THREAD_SAFE_FUNCTIONS = 68,
    _SC_GETGR_R_SIZE_MAX = 69,
    _SC_GETPW_R_SIZE_MAX = 70,
    _SC_LOGIN_NAME_MAX = 71,
    _SC_TTY_NAME_MAX = 72,
    _SC_THREAD_DESTRUCTOR_ITERATIONS = 73,
    _SC_THREAD_KEYS_MAX = 74,
    _SC_THREAD_STACK_MIN = 75,
    _SC_THREAD_THREADS_MAX = 76,
    _SC_THREAD_ATTR_STACKADDR = 77,
    _SC_THREAD_ATTR_STACKSIZE = 78,
    _SC_THREAD_PRIORITY_SCHEDULING = 79,
    _SC_THREAD_PRIO_INHERIT = 80,
    _SC_THREAD_PRIO_PROTECT = 81,
    _SC_THREAD_PROCESS_SHARED = 82,
    _SC_NPROCESSORS_CONF = 83,
    _SC_NPROCESSORS_ONLN = 84,
    _SC_PHYS_PAGES = 85,
    _SC_AVPHYS_PAGES = 86,
    _SC_ATEXIT_MAX = 87,
    _SC_PASS_MAX = 88,
    _SC_XOPEN_VERSION = 89,
    _SC_XOPEN_XCU_VERSION = 90,
    _SC_XOPEN_UNIX = 91,
    _SC_XOPEN_CRYPT = 92,
    _SC_XOPEN_ENH_I18N = 93,
    _SC_XOPEN_SHM = 94,
    _SC_2_CHAR_TERM = 95,
    _SC_2_C_VERSION = 96,
    _SC_2_UPE = 97,
    _SC_XOPEN_XPG2 = 98,
    _SC_XOPEN_XPG3 = 99,
    _SC_XOPEN_XPG4 = 100,
    _SC_CHAR_BIT = 101,
    _SC_CHAR_MAX = 102,
    _SC_CHAR_MIN = 103,
    _SC_INT_MAX = 104,
    _SC_INT_MIN = 105,
    _SC_LONG_BIT = 106,
    _SC_WORD_BIT = 107,
    _SC_MB_LEN_MAX = 108,
    _SC_NZERO = 109,
    _SC_SSIZE_MAX = 110,
    _SC_SCHAR_MAX = 111,
    _SC_SCHAR_MIN = 112,
    _SC_SHRT_MAX = 113,
    _SC_SHRT_MIN = 114,
    _SC_UCHAR_MAX = 115,
    _SC_UINT_MAX = 116,
    _SC_ULONG_MAX = 117,
    _SC_USHRT_MAX = 118,
    _SC_NL_ARGMAX = 119,
    _SC_NL_LANGMAX = 120,
    _SC_NL_MSGMAX = 121,
    _SC_NL_NMAX = 122,
    _SC_NL_SETMAX = 123,
    _SC_NL_TEXTMAX = 124,
    _SC_XBS5_ILP32_OFF32 = 125,
    _SC_XBS5_ILP32_OFFBIG = 126,
    _SC_XBS5_LP64_OFF64 = 127,
    _SC_XBS5_LPBIG_OFFBIG = 128,
    _SC_XOPEN_LEGACY = 129,
    _SC_XOPEN_REALTIME = 130,
    _SC_XOPEN_REALTIME_THREADS = 131,
    _SC_ADVISORY_INFO = 132,
    _SC_BARRIERS = 133,
    _SC_BASE = 134,
    _SC_C_LANG_SUPPORT = 135,
    _SC_C_LANG_SUPPORT_R = 136,
    _SC_CLOCK_SELECTION = 137,
    _SC_CPUTIME = 138,
    _SC_THREAD_CPUTIME = 139,
    _SC_DEVICE_IO = 140,
    _SC_DEVICE_SPECIFIC = 141,
    _SC_DEVICE_SPECIFIC_R = 142,
    _SC_FD_MGMT = 143,
    _SC_FIFO = 144,
    _SC_PIPE = 145,
    _SC_FILE_ATTRIBUTES = 146,
    _SC_FILE_LOCKING = 147,
    _SC_FILE_SYSTEM = 148,
    _SC_MONOTONIC_CLOCK = 149,
    _SC_MULTI_PROCESS = 150,
    _SC_SINGLE_PROCESS = 151,
    _SC_NETWORKING = 152,
    _SC_READER_WRITER_LOCKS = 153,
    _SC_SPIN_LOCKS = 154,
    _SC_REGEXP = 155,
    _SC_REGEX_VERSION = 156,
    _SC_SHELL = 157,
    _SC_SIGNALS = 158,
    _SC_SPAWN = 159,
    _SC_SPORADIC_SERVER = 160,
    _SC_THREAD_SPORADIC_SERVER = 161,
    _SC_SYSTEM_DATABASE = 162,
    _SC_SYSTEM_DATABASE_R = 163,
    _SC_TIMEOUTS = 164,
    _SC_TYPED_MEMORY_OBJECTS = 165,
    _SC_USER_GROUPS = 166,
    _SC_USER_GROUPS_R = 167,
    _SC_2_PBS = 168,
    _SC_2_PBS_ACCOUNTING = 169,
    _SC_2_PBS_LOCATE = 170,
    _SC_2_PBS_MESSAGE = 171,
    _SC_2_PBS_TRACK = 172,
    _SC_SYMLOOP_MAX = 173,
    _SC_STREAMS = 174,
    _SC_2_PBS_CHECKPOINT = 175,
    _SC_V6_ILP32_OFF32 = 176,
    _SC_V6_ILP32_OFFBIG = 177,
    _SC_V6_LP64_OFF64 = 178,
    _SC_V6_LPBIG_OFFBIG = 179,
    _SC_HOST_NAME_MAX = 180,
    _SC_TRACE = 181,
    _SC_TRACE_EVENT_FILTER = 182,
    _SC_TRACE_INHERIT = 183,
    _SC_TRACE_LOG = 184,
    _SC_LEVEL1_ICACHE_SIZE = 185,
    _SC_LEVEL1_ICACHE_ASSOC = 186,
    _SC_LEVEL1_ICACHE_LINESIZE = 187,
    _SC_LEVEL1_DCACHE_SIZE = 188,
    _SC_LEVEL1_DCACHE_ASSOC = 189,
    _SC_LEVEL1_DCACHE_LINESIZE = 190,
    _SC_LEVEL2_CACHE_SIZE = 191,
    _SC_LEVEL2_CACHE_ASSOC = 192,
    _SC_LEVEL2_CACHE_LINESIZE = 193,
    _SC_LEVEL3_CACHE_SIZE = 194,
    _SC_LEVEL3_CACHE_ASSOC = 195,
    _SC_LEVEL3_CACHE_LINESIZE = 196,
    _SC_LEVEL4_CACHE_SIZE = 197,
    _SC_LEVEL4_CACHE_ASSOC = 198,
    _SC_LEVEL4_CACHE_LINESIZE = 199,
    _SC_IPV6 = 235,
    _SC_RAW_SOCKETS = 236,
    _SC_V7_ILP32_OFF32 = 237,
    _SC_V7_ILP32_OFFBIG = 238,
    _SC_V7_LP64_OFF64 = 239,
    _SC_V7_LPBIG_OFFBIG = 240,
    _SC_SS_REPL_MAX = 241,
    _SC_TRACE_EVENT_NAME_MAX = 242,
    _SC_TRACE_NAME_MAX = 243,
    _SC_TRACE_SYS_MAX = 244,
    _SC_TRACE_USER_EVENT_MAX = 245,
    _SC_XOPEN_STREAMS = 246,
    _SC_THREAD_ROBUST_PRIO_INHERIT = 247,
    _SC_THREAD_ROBUST_PRIO_PROTECT = 248
} ;
enum __anonenum_57;
enum __anonenum_56 {
    _PC_LINK_MAX = 0,
    _PC_MAX_CANON = 1,
    _PC_MAX_INPUT = 2,
    _PC_NAME_MAX = 3,
    _PC_PATH_MAX = 4,
    _PC_PIPE_BUF = 5,
    _PC_CHOWN_RESTRICTED = 6,
    _PC_NO_TRUNC = 7,
    _PC_VDISABLE = 8,
    _PC_SYNC_IO = 9,
    _PC_ASYNC_IO = 10,
    _PC_PRIO_IO = 11,
    _PC_SOCK_MAXBUF = 12,
    _PC_FILESIZEBITS = 13,
    _PC_REC_INCR_XFER_SIZE = 14,
    _PC_REC_MAX_XFER_SIZE = 15,
    _PC_REC_MIN_XFER_SIZE = 16,
    _PC_REC_XFER_ALIGN = 17,
    _PC_ALLOC_SIZE_MIN = 18,
    _PC_SYMLINK_MAX = 19,
    _PC_2_SYMLINKS = 20
} ;
enum __anonenum_56;
enum __anonenum_55 {
    _ISupper = 256,
    _ISlower = 512,
    _ISalpha = 1024,
    _ISdigit = 2048,
    _ISxdigit = 4096,
    _ISspace = 8192,
    _ISprint = 16384,
    _ISgraph = 32768,
    _ISblank = 1,
    _IScntrl = 2,
    _ISpunct = 4,
    _ISalnum = 8
} ;
enum __anonenum_55;
struct _zend_free_op {
   zval *var ;
};
struct _HashPointer {
   HashPosition pos ;
   ulong h ;
};
struct __anonstruct_fe_54 {
   zval **ptr_ptr ;
   zval *ptr ;
   HashPointer fe_pos ;
};
struct __anonstruct_str_offset_53 {
   zval **ptr_ptr ;
   zval *str ;
   zend_uint offset ;
};
struct __anonstruct_var_52 {
   zval **ptr_ptr ;
   zval *ptr ;
   zend_bool fcall_returned_reference ;
};
union _temp_variable {
   zval tmp_var ;
   struct __anonstruct_var_52 var ;
   struct __anonstruct_str_offset_53 str_offset ;
   struct __anonstruct_fe_54 fe ;
   zend_class_entry *class_entry ;
};
struct __anonstruct_fe_54;
struct __anonstruct_str_offset_53;
struct __anonstruct_var_52;
struct _zend_rsrc_list_dtors_entry;
typedef struct _zend_rsrc_list_dtors_entry zend_rsrc_list_dtors_entry;
struct _zend_rsrc_list_dtors_entry {
   void (*list_dtor)(void * ) ;
   void (*plist_dtor)(void * ) ;
   void (*list_dtor_ex)(zend_rsrc_list_entry *rsrc ) ;
   void (*plist_dtor_ex)(zend_rsrc_list_entry *rsrc ) ;
   char const   *type_name ;
   int module_number ;
   int resource_id ;
   unsigned char type ;
};
typedef void (*rsrc_dtor_func_t)(zend_rsrc_list_entry *rsrc );
struct _zend_rsrc_list_entry {
   void *ptr ;
   int type ;
   int refcount ;
};
struct _zend_module_dep {
   char const   *name ;
   char const   *rel ;
   char const   *version ;
   unsigned char type ;
};
struct _zend_module_dep;
struct _zend_module_entry {
   unsigned short size ;
   unsigned int zend_api ;
   unsigned char zend_debug ;
   unsigned char zts ;
   struct _zend_ini_entry  const  *ini_entry ;
   struct _zend_module_dep  const  *deps ;
   char const   *name ;
   struct _zend_function_entry  const  *functions ;
   int (*module_startup_func)(int type , int module_number ) ;
   int (*module_shutdown_func)(int type , int module_number ) ;
   int (*request_startup_func)(int type , int module_number ) ;
   int (*request_shutdown_func)(int type , int module_number ) ;
   void (*info_func)(zend_module_entry *zend_module ) ;
   char const   *version ;
   size_t globals_size ;
   void *globals_ptr ;
   void (*globals_ctor)(void *global ) ;
   void (*globals_dtor)(void *global ) ;
   int (*post_deactivate_func)(void) ;
   int module_started ;
   unsigned char type ;
   void *handle ;
   int module_number ;
   char const   *build_id ;
};
typedef struct _zend_module_dep zend_module_dep;
struct _zend_auto_global;
typedef struct _zend_auto_global zend_auto_global;
struct _zend_auto_global {
   char *name ;
   uint name_len ;
   zend_bool (*auto_global_callback)(char *name , uint name_len ) ;
   zend_bool jit ;
   zend_bool armed ;
};
typedef zend_bool (*zend_auto_global_callback)(char *name , uint name_len );
struct _zend_php_scanner_globals {
   zend_file_handle *yy_in ;
   zend_file_handle *yy_out ;
   unsigned int yy_leng ;
   unsigned char *yy_start ;
   unsigned char *yy_text ;
   unsigned char *yy_cursor ;
   unsigned char *yy_marker ;
   unsigned char *yy_limit ;
   int yy_state ;
   zend_stack state_stack ;
   unsigned char *script_org ;
   size_t script_org_size ;
   unsigned char *script_filtered ;
   size_t script_filtered_size ;
   size_t (*input_filter)(unsigned char **str , size_t *str_length ,
                          unsigned char const   *buf , size_t length ) ;
   size_t (*output_filter)(unsigned char **str , size_t *str_length ,
                           unsigned char const   *buf , size_t length ) ;
   zend_encoding const   *script_encoding ;
};
struct _zend_ini_scanner_globals {
   zend_file_handle *yy_in ;
   zend_file_handle *yy_out ;
   unsigned int yy_leng ;
   unsigned char *yy_start ;
   unsigned char *yy_text ;
   unsigned char *yy_cursor ;
   unsigned char *yy_marker ;
   unsigned char *yy_limit ;
   int yy_state ;
   zend_stack state_stack ;
   char *filename ;
   int lineno ;
   int scanner_mode ;
};
struct _zend_compiler_context {
   zend_uint opcodes_size ;
   int vars_size ;
   int literals_size ;
   int current_brk_cont ;
   int backpatch_count ;
   HashTable *labels ;
};
typedef struct _zend_compiler_context zend_compiler_context;
union __anonunion_u_49 {
   znode_op op ;
   zval constant ;
   zend_op_array *op_array ;
};
struct _znode {
   int op_type ;
   union __anonunion_u_49 u ;
   zend_uint EA ;
};
struct _zend_declarables {
   zval ticks ;
};
typedef struct _zend_declarables zend_declarables;
struct _zend_compiler_globals {
   zend_stack bp_stack ;
   zend_stack switch_cond_stack ;
   zend_stack foreach_copy_stack ;
   zend_stack object_stack ;
   zend_stack declare_stack ;
   zend_class_entry *active_class_entry ;
   zend_llist list_llist ;
   zend_llist dimension_llist ;
   zend_stack list_stack ;
   zend_stack function_call_stack ;
   char *compiled_filename ;
   int zend_lineno ;
   char *heredoc ;
   int heredoc_len ;
   zend_op_array *active_op_array ;
   HashTable *function_table ;
   HashTable *class_table ;
   HashTable filenames_table ;
   HashTable *auto_globals ;
   zend_bool in_compilation ;
   zend_bool short_tags ;
   zend_bool asp_tags ;
   zend_declarables declarables ;
   zend_bool unclean_shutdown ;
   zend_bool ini_parser_unbuffered_errors ;
   zend_llist open_files ;
   long catch_begin ;
   struct _zend_ini_parser_param *ini_parser_param ;
   int interactive ;
   zend_uint start_lineno ;
   zend_bool increment_lineno ;
   znode implementing_class ;
   zend_uint access_type ;
   char *doc_comment ;
   zend_uint doc_comment_len ;
   zend_uint compiler_options ;
   zval *current_namespace ;
   HashTable *current_import ;
   zend_bool in_namespace ;
   zend_bool has_bracketed_namespaces ;
   zend_compiler_context context ;
   zend_stack context_stack ;
   char *interned_strings_start ;
   char *interned_strings_end ;
   char *interned_strings_top ;
   char *interned_strings_snapshot_top ;
   HashTable interned_strings ;
   zend_encoding const   **script_encoding_list ;
   size_t script_encoding_list_size ;
   zend_bool multibyte ;
   zend_bool detect_unicode ;
   zend_bool encoding_declared ;
};
struct _zend_declarables;
struct _zend_multibyte_functions {
   char const   *provider_name ;
   zend_encoding const   *(*encoding_fetcher)(char const   *encoding_name ) ;
   char const   *(*encoding_name_getter)(zend_encoding const   *encoding ) ;
   int (*lexer_compatibility_checker)(zend_encoding const   *encoding ) ;
   zend_encoding const   *(*encoding_detector)(unsigned char const   *string ,
                                               size_t length ,
                                               zend_encoding const   **list ,
                                               size_t list_size ) ;
   size_t (*encoding_converter)(unsigned char **to , size_t *to_length ,
                                unsigned char const   *from ,
                                size_t from_length ,
                                zend_encoding const   *encoding_to ,
                                zend_encoding const   *encoding_from ) ;
   int (*encoding_list_parser)(char const   *encoding_list ,
                               size_t encoding_list_len ,
                               zend_encoding const   ***return_list ,
                               size_t *return_size , int persistent ) ;
   zend_encoding const   *(*internal_encoding_getter)(void) ;
   int (*internal_encoding_setter)(zend_encoding const   *encoding ) ;
};
typedef int (*zend_encoding_internal_encoding_setter)(zend_encoding const   *encoding );
typedef zend_encoding const   *(*zend_encoding_internal_encoding_getter)(void);
typedef int (*zend_encoding_list_parser)(char const   *encoding_list ,
                                         size_t encoding_list_len ,
                                         zend_encoding const   ***return_list ,
                                         size_t *return_size , int persistent );
typedef size_t (*zend_encoding_converter)(unsigned char **to ,
                                          size_t *to_length ,
                                          unsigned char const   *from ,
                                          size_t from_length ,
                                          zend_encoding const   *encoding_to ,
                                          zend_encoding const   *encoding_from );
typedef zend_encoding const   *(*zend_encoding_detector)(unsigned char const   *string ,
                                                         size_t length ,
                                                         zend_encoding const   **list ,
                                                         size_t list_size );
typedef int (*zend_encoding_lexer_compatibility_checker)(zend_encoding const   *encoding );
typedef char const   *(*zend_encoding_name_getter)(zend_encoding const   *encoding );
typedef zend_encoding const   *(*zend_encoding_fetcher)(char const   *encoding_name );
typedef size_t (*zend_encoding_filter)(unsigned char **str ,
                                       size_t *str_length ,
                                       unsigned char const   *buf ,
                                       size_t length );
struct __anonstruct_free_list_51 {
   int next ;
};
struct _store_object {
   void *object ;
   void (*dtor)(void *object , zend_object_handle handle ) ;
   void (*free_storage)(void *object ) ;
   void (*clone)(void *object , void **object_clone ) ;
   zend_object_handlers const   *handlers ;
   zend_uint refcount ;
   gc_root_buffer *buffered ;
};
union _store_bucket {
   struct _store_object obj ;
   struct __anonstruct_free_list_51 free_list ;
};
struct _zend_object_store_bucket {
   zend_bool destructor_called ;
   zend_bool valid ;
   union _store_bucket bucket ;
};
union _store_bucket;
struct __anonstruct_free_list_51;
struct _store_object;
typedef void (*zend_objects_store_clone_t)(void *object , void **object_clone );
typedef void (*zend_objects_free_object_storage_t)(void *object );
typedef void (*zend_objects_store_dtor_t)(void *object ,
                                          zend_object_handle handle );
typedef struct _zend_compiler_globals zend_compiler_globals;
typedef struct __jmp_buf_tag sigjmp_buf[1];
struct _list_llist_element;
typedef struct _list_llist_element list_llist_element;
struct _list_llist_element {
   znode var ;
   zend_llist dimensions ;
   znode value ;
};
struct _zend_switch_entry;
typedef struct _zend_switch_entry zend_switch_entry;
struct _zend_switch_entry {
   znode cond ;
   int default_case ;
   int control_var ;
};
struct _zend_function_state;
struct _zend_internal_function {
   zend_uchar type ;
   char *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
   void (*handler)(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
   struct _zend_module_entry *module ;
};
typedef struct _zend_internal_function zend_internal_function;
struct _zend_try_catch_element;
typedef struct _zend_try_catch_element zend_try_catch_element;
struct _zend_compiled_variable;
typedef struct _zend_compiled_variable zend_compiled_variable;
struct _zend_op_array {
   zend_uchar type ;
   char *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
   zend_uint *refcount ;
   zend_op *opcodes ;
   zend_uint last ;
   zend_compiled_variable *vars ;
   int last_var ;
   zend_uint T ;
   zend_brk_cont_element *brk_cont_array ;
   int last_brk_cont ;
   zend_try_catch_element *try_catch_array ;
   int last_try_catch ;
   HashTable *static_variables ;
   zend_uint this_var ;
   char *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char *doc_comment ;
   zend_uint doc_comment_len ;
   zend_uint early_binding ;
   zend_literal *literals ;
   int last_literal ;
   void **run_time_cache ;
   int last_cache_slot ;
   void *reserved[4] ;
};
struct __anonstruct_common_50 {
   zend_uchar type ;
   char *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
};
union _zend_function {
   zend_uchar type ;
   struct __anonstruct_common_50 common ;
   zend_op_array op_array ;
   zend_internal_function internal_function ;
};
struct __anonstruct_common_50;
struct _zend_internal_function;
struct _zend_compiled_variable {
   char *name ;
   int name_len ;
   ulong hash_value ;
};
struct _zend_internal_function_info;
typedef struct _zend_internal_function_info zend_internal_function_info;
struct _zend_internal_function_info {
   char const   *_name ;
   zend_uint _name_len ;
   char const   *_class_name ;
   zend_uint required_num_args ;
   zend_uchar _type_hint ;
   zend_bool return_reference ;
   zend_bool pass_rest_by_reference ;
};
struct _zend_try_catch_element {
   zend_uint try_op ;
   zend_uint catch_op ;
};
struct _zend_label;
typedef struct _zend_label zend_label;
struct _zend_label {
   int brk_cont ;
   zend_uint opline_num ;
};
struct _zend_brk_cont_element {
   int start ;
   int cont ;
   int brk ;
   int parent ;
};
union __anonunion_u_49;
struct _zend_literal {
   zval constant ;
   zend_ulong hash_value ;
   zend_uint cache_slot ;
};
struct _zend_compiler_context;
typedef int error_t;
union __anonunion_u_46;
union __anonunion_u_45;
typedef int (*zend_write_func_t)(char const   *str , uint str_length );
struct _zend_utility_values {
   char *import_use_extension ;
   uint import_use_extension_length ;
   zend_bool html_errors ;
};
struct _zend_utility_functions {
   void ( /* format attribute */  (*error_function))(int type ,
                                                     char const   *error_filename ,
                                                     uint error_lineno ,
                                                     char const   *format ,
                                                     va_list args ) ;
   int ( /* format attribute */  (*printf_function))(char const   *format  , ...) ;
   int (*write_function)(char const   *str , uint str_length ) ;
   FILE *(*fopen_function)(char const   *filename , char **opened_path ) ;
   void (*message_handler)(long message , void *data ) ;
   void (*block_interruptions)(void) ;
   void (*unblock_interruptions)(void) ;
   int (*get_configuration_directive)(char const   *name , uint name_length ,
                                      zval *contents ) ;
   void (*ticks_function)(int ticks ) ;
   void (*on_timeout)(int seconds ) ;
   int (*stream_open_function)(char const   *filename ,
                               zend_file_handle *handle ) ;
   int (*vspprintf_function)(char **pbuf , size_t max_len ,
                             char const   *format , va_list ap ) ;
   char *(*getenv_function)(char *name , size_t name_len ) ;
   char *(*resolve_path_function)(char const   *filename , int filename_len ) ;
};
struct _zend_mmap {
   size_t len ;
   size_t pos ;
   void *map ;
   char *buf ;
   void *old_handle ;
   void (*old_closer)(void *handle ) ;
};
typedef struct _zend_mmap zend_mmap;
struct _zend_stream {
   void *handle ;
   int isatty ;
   zend_mmap mmap ;
   size_t (*reader)(void *handle , char *buf , size_t len ) ;
   size_t (*fsizer)(void *handle ) ;
   void (*closer)(void *handle ) ;
};
typedef struct _zend_stream zend_stream;
union __anonunion_handle_44 {
   int fd ;
   FILE *fp ;
   zend_stream stream ;
};
enum __anonenum_zend_stream_type_43 {
    ZEND_HANDLE_FILENAME = 0,
    ZEND_HANDLE_FD = 1,
    ZEND_HANDLE_FP = 2,
    ZEND_HANDLE_STREAM = 3,
    ZEND_HANDLE_MAPPED = 4
} ;
typedef enum __anonenum_zend_stream_type_43 zend_stream_type;
struct _zend_file_handle {
   zend_stream_type type ;
   char *filename ;
   char *opened_path ;
   union __anonunion_handle_44 handle ;
   zend_bool free_filename ;
};
union __anonunion_handle_44;
struct _zend_stream;
struct _zend_mmap;
enum __anonenum_zend_stream_type_43;
typedef void (*zend_stream_closer_t)(void *handle );
typedef size_t (*zend_stream_reader_t)(void *handle , char *buf , size_t len );
typedef size_t (*zend_stream_fsizer_t)(void *handle );
union __anonunion_info_40;
struct __anonstruct_internal_42;
struct __anonstruct_user_41;
struct _zend_trait_method_reference;
typedef struct _zend_trait_method_reference zend_trait_method_reference;
struct _zend_trait_alias {
   zend_trait_method_reference *trait_method ;
   char *alias ;
   unsigned int alias_len ;
   zend_uint modifiers ;
   union _zend_function *function ;
};
struct _zend_trait_precedence {
   zend_trait_method_reference *trait_method ;
   zend_class_entry **exclude_from_classes ;
   union _zend_function *function ;
};
struct _zend_trait_method_reference {
   char *method_name ;
   unsigned int mname_len ;
   zend_class_entry *ce ;
   char *class_name ;
   unsigned int cname_len ;
};
enum zend_object_iterator_kind {
    ZEND_ITER_INVALID = 0,
    ZEND_ITER_PLAIN_ARRAY = 1,
    ZEND_ITER_PLAIN_OBJECT = 2,
    ZEND_ITER_OBJECT = 3
} ;
struct _zend_class_iterator_funcs;
struct _zend_object_iterator_funcs {
   void (*dtor)(zend_object_iterator *iter ) ;
   int (*valid)(zend_object_iterator *iter ) ;
   void (*get_current_data)(zend_object_iterator *iter , zval ***data ) ;
   int (*get_current_key)(zend_object_iterator *iter , char **str_key ,
                          uint *str_key_len , ulong *int_key ) ;
   void (*move_forward)(zend_object_iterator *iter ) ;
   void (*rewind)(zend_object_iterator *iter ) ;
   void (*invalidate_current)(zend_object_iterator *iter ) ;
};
union _zvalue_value;
struct __anonstruct_str_39;
typedef int (*zend_object_get_closure_t)(zval *obj , zend_class_entry **ce_ptr ,
                                         union _zend_function **fptr_ptr ,
                                         zval **zobj_ptr );
typedef int (*zend_object_count_elements_t)(zval *object , long *count );
typedef int (*zend_object_cast_t)(zval *readobj , zval *retval , int type );
typedef int (*zend_object_compare_t)(zval *object1 , zval *object2 );
typedef int (*zend_object_get_class_name_t)(zval const   *object ,
                                            char **class_name ,
                                            zend_uint *class_name_len ,
                                            int parent );
typedef zend_class_entry *(*zend_object_get_class_entry_t)(zval const   *object );
typedef zend_object_value (*zend_object_clone_obj_t)(zval *object );
typedef void (*zend_object_delete_obj_t)(zval *object );
typedef void (*zend_object_del_ref_t)(zval *object );
typedef void (*zend_object_add_ref_t)(zval *object );
typedef union _zend_function *(*zend_object_get_constructor_t)(zval *object );
typedef union _zend_function *(*zend_object_get_method_t)(zval **object_ptr ,
                                                          char *method ,
                                                          int method_len ,
                                                          struct _zend_literal  const  *key );
typedef int (*zend_object_call_method_t)(char *method , int ht ,
                                         zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used );
typedef HashTable *(*zend_object_get_debug_info_t)(zval *object , int *is_temp );
typedef HashTable *(*zend_object_get_properties_t)(zval *object );
typedef void (*zend_object_unset_dimension_t)(zval *object , zval *offset );
typedef void (*zend_object_unset_property_t)(zval *object , zval *member ,
                                             struct _zend_literal  const  *key );
typedef int (*zend_object_has_dimension_t)(zval *object , zval *member ,
                                           int check_empty );
typedef int (*zend_object_has_property_t)(zval *object , zval *member ,
                                          int has_set_exists ,
                                          struct _zend_literal  const  *key );
typedef zval *(*zend_object_get_t)(zval *object );
typedef void (*zend_object_set_t)(zval **object , zval *value );
typedef zval **(*zend_object_get_property_ptr_ptr_t)(zval *object ,
                                                     zval *member ,
                                                     struct _zend_literal  const  *key );
typedef void (*zend_object_write_dimension_t)(zval *object , zval *offset ,
                                              zval *value );
typedef void (*zend_object_write_property_t)(zval *object , zval *member ,
                                             zval *value ,
                                             struct _zend_literal  const  *key );
typedef zval *(*zend_object_read_dimension_t)(zval *object , zval *offset ,
                                              int type );
typedef zval *(*zend_object_read_property_t)(zval *object , zval *member ,
                                             int type ,
                                             struct _zend_literal  const  *key );
struct _zend_guard;
typedef struct _zend_guard zend_guard;
struct _zend_guard {
   zend_bool in_get ;
   zend_bool in_set ;
   zend_bool in_unset ;
   zend_bool in_isset ;
   zend_bool dummy ;
};
typedef void (*llist_apply_func_t)(void * );
typedef void (*llist_apply_with_arg_func_t)(void *data , void *arg );
typedef void (*llist_apply_with_args_func_t)(void *data , int num_args ,
                                             va_list args );
typedef int (*llist_compare_func_t)(zend_llist_element const   ** ,
                                    zend_llist_element const   ** );
typedef void (*llist_dtor_func_t)(void * );
struct _zend_llist_element {
   struct _zend_llist_element *next ;
   struct _zend_llist_element *prev ;
   char data[1] ;
};
struct _zend_ts_hashtable {
   HashTable hash ;
   zend_uint reader ;
};
typedef int (*apply_func_args_t)(void *pDest , int num_args , va_list args ,
                                 zend_hash_key *hash_key );
typedef int (*apply_func_arg_t)(void *pDest , void *argument );
typedef int (*apply_func_t)(void *pDest );
typedef zend_bool (*merge_checker_func_t)(HashTable *target_ht ,
                                          void *source_data ,
                                          zend_hash_key *hash_key ,
                                          void *pParam );
struct _zend_hash_key {
   char *arKey ;
   uint nKeyLength ;
   ulong h ;
};
struct bucket {
   ulong h ;
   uint nKeyLength ;
   void *pData ;
   void *pDataPtr ;
   struct bucket *pListNext ;
   struct bucket *pListLast ;
   struct bucket *pNext ;
   struct bucket *pLast ;
   char *arKey ;
};
typedef void (*copy_ctor_param_func_t)(void *pElement , void *pParam );
typedef void (*copy_ctor_func_t)(void *pElement );
typedef void (*dtor_func_t)(void *pDest );
typedef void (*sort_func_t)(void * , size_t  , size_t  ,
                            int (*)(void const   * , void const   * ) );
typedef int (*compare_func_t)(void const   * , void const   * );
typedef ulong (*hash_func_t)(char const   *arKey , uint nKeyLength );
typedef unsigned long zend_uintptr_t;
typedef long zend_intptr_t;
typedef unsigned long long zend_ulong64;
typedef long long zend_long64;
typedef unsigned short zend_ushort;
struct _zend_mm_storage {
   zend_mm_mem_handlers const   *handlers ;
   void *data ;
};
struct _zend_mm_segment;
typedef struct _zend_mm_segment zend_mm_segment;
struct _zend_mm_mem_handlers {
   char const   *name ;
   zend_mm_storage *(*init)(void *params ) ;
   void (*dtor)(zend_mm_storage *storage ) ;
   void (*compact)(zend_mm_storage *storage ) ;
   zend_mm_segment *(*_alloc)(zend_mm_storage *storage , size_t size ) ;
   zend_mm_segment *(*_realloc)(zend_mm_storage *storage ,
                                zend_mm_segment *ptr , size_t size ) ;
   void (*_free)(zend_mm_storage *storage , zend_mm_segment *ptr ) ;
};
struct _zend_mm_segment {
   size_t size ;
   struct _zend_mm_segment *next_segment ;
};
struct _zend_leak_info;
typedef struct _zend_leak_info zend_leak_info;
struct _zend_leak_info {
   void *addr ;
   size_t size ;
   char *filename ;
   uint lineno ;
   char *orig_filename ;
   uint orig_lineno ;
};
typedef unsigned long tsrm_uintptr_t;
typedef long tsrm_intptr_t;
struct __anonstruct_Dl_serinfo_38;
typedef struct __anonstruct_Dl_serinfo_38 Dl_serinfo;
struct __anonstruct_Dl_serpath_37 {
   char *dls_name ;
   unsigned int dls_flags ;
};
typedef struct __anonstruct_Dl_serpath_37 Dl_serpath;
struct __anonstruct_Dl_serinfo_38 {
   size_t dls_size ;
   unsigned int dls_cnt ;
   Dl_serpath dls_serpath[1] ;
};
struct __anonstruct_Dl_serpath_37;
enum __anonenum_36 {
    RTLD_DI_LMID = 1,
    RTLD_DI_LINKMAP = 2,
    RTLD_DI_CONFIGADDR = 3,
    RTLD_DI_SERINFO = 4,
    RTLD_DI_SERINFOSIZE = 5,
    RTLD_DI_ORIGIN = 6,
    RTLD_DI_PROFILENAME = 7,
    RTLD_DI_PROFILEOUT = 8,
    RTLD_DI_TLS_MODID = 9,
    RTLD_DI_TLS_DATA = 10,
    RTLD_DI_MAX = 10
} ;
enum __anonenum_36;
enum __anonenum_35 {
    RTLD_DL_SYMENT = 1,
    RTLD_DL_LINKMAP = 2
} ;
enum __anonenum_35;
struct __anonstruct_Dl_info_34 {
   char const   *dli_fname ;
   void *dli_fbase ;
   char const   *dli_sname ;
   void *dli_saddr ;
};
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
typedef int __io_close_fn(void *__cookie );
typedef int __io_seek_fn(void *__cookie , __off64_t *__pos , int __w );
typedef __ssize_t __io_write_fn(void *__cookie , char const   *__buf ,
                                size_t __n );
typedef __ssize_t __io_read_fn(void *__cookie , char *__buf , size_t __nbytes );
struct __anonstruct__IO_cookie_io_functions_t_33 {
   __io_read_fn *read ;
   __io_write_fn *write ;
   __io_seek_fn *seek ;
   __io_close_fn *close ;
};
typedef __io_close_fn cookie_close_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_read_fn cookie_read_function_t;
enum __codecvt_result {
    __codecvt_ok = 0,
    __codecvt_partial = 1,
    __codecvt_error = 2,
    __codecvt_noconv = 3
} ;
enum __codecvt_result;
struct _IO_marker {
   struct _IO_marker *_next ;
   struct _IO_FILE *_sbuf ;
   int _pos ;
};
struct _IO_jump_t;
typedef unsigned int _G_uint32_t;
typedef unsigned short _G_uint16_t;
typedef int _G_int32_t;
typedef short _G_int16_t;
union __anonunion___value_30 {
   unsigned int __wch ;
   char __wchb[4] ;
};
struct __anonstruct___mbstate_t_29 {
   int __count ;
   union __anonunion___value_30 __value ;
};
typedef struct __anonstruct___mbstate_t_29 __mbstate_t;
struct __anonstruct__G_fpos64_t_32 {
   __off64_t __pos ;
   __mbstate_t __state ;
};
struct __anonstruct__G_fpos_t_31 {
   __off_t __pos ;
   __mbstate_t __state ;
};
struct __anonstruct___mbstate_t_29;
union __anonunion___value_30;
typedef struct _IO_FILE __FILE;
union __anonunion_28;
union __anonunion___n_27;
union __anonunion___u_26;
union __anonunion___u_25;
union __anonunion___u_24;
struct exception {
   int type ;
   char *name ;
   double arg1 ;
   double arg2 ;
   double retval ;
};
enum __anonenum__LIB_VERSION_TYPE_23 {
    _IEEE_ = -1,
    _SVID_ = 0,
    _XOPEN_ = 1,
    _POSIX_ = 2,
    _ISOC_ = 3
} ;
enum __anonenum_22 {
    FP_NAN = 0,
    FP_INFINITE = 1,
    FP_ZERO = 2,
    FP_SUBNORMAL = 3,
    FP_NORMAL = 4
} ;
enum __anonenum_22;
typedef long double double_t;
typedef long double float_t;
typedef int (*__compar_d_fn_t)(void const   * , void const   * , void * );
typedef int (*comparison_fn_t)(void const   * , void const   * );
typedef int (*__compar_fn_t)(void const   * , void const   * );
struct drand48_data {
   unsigned short __x[3] ;
   unsigned short __old_x[3] ;
   unsigned short __c ;
   unsigned short __init ;
   unsigned long long __a ;
};
struct random_data {
   int32_t *fptr ;
   int32_t *rptr ;
   int32_t *state ;
   int rand_type ;
   int rand_deg ;
   int rand_sep ;
   int32_t *end_ptr ;
};
union __anonunion_pthread_barrierattr_t_21;
typedef union __anonunion_pthread_barrierattr_t_21 pthread_barrierattr_t;
union __anonunion_pthread_barrierattr_t_21 {
   char __size[4] ;
   int __align ;
};
union __anonunion_pthread_barrier_t_20;
typedef union __anonunion_pthread_barrier_t_20 pthread_barrier_t;
union __anonunion_pthread_barrier_t_20 {
   char __size[20] ;
   long __align ;
};
typedef int volatile   pthread_spinlock_t;
union __anonunion_pthread_rwlockattr_t_19;
typedef union __anonunion_pthread_rwlockattr_t_19 pthread_rwlockattr_t;
union __anonunion_pthread_rwlockattr_t_19 {
   char __size[8] ;
   long __align ;
};
union __anonunion_pthread_rwlock_t_17;
typedef union __anonunion_pthread_rwlock_t_17 pthread_rwlock_t;
struct __anonstruct___data_18 {
   int __lock ;
   unsigned int __nr_readers ;
   unsigned int __readers_wakeup ;
   unsigned int __writer_wakeup ;
   unsigned int __nr_readers_queued ;
   unsigned int __nr_writers_queued ;
   unsigned char __flags ;
   unsigned char __shared ;
   unsigned char __pad1 ;
   unsigned char __pad2 ;
   int __writer ;
};
union __anonunion_pthread_rwlock_t_17 {
   struct __anonstruct___data_18 __data ;
   char __size[32] ;
   long __align ;
};
struct __anonstruct___data_18;
typedef int pthread_once_t;
typedef unsigned int pthread_key_t;
union __anonunion_pthread_condattr_t_16;
typedef union __anonunion_pthread_condattr_t_16 pthread_condattr_t;
union __anonunion_pthread_condattr_t_16 {
   char __size[4] ;
   long __align ;
};
union __anonunion_pthread_cond_t_14;
typedef union __anonunion_pthread_cond_t_14 pthread_cond_t;
struct __anonstruct___data_15 {
   int __lock ;
   unsigned int __futex ;
   unsigned long long __total_seq ;
   unsigned long long __wakeup_seq ;
   unsigned long long __woken_seq ;
   void *__mutex ;
   unsigned int __nwaiters ;
   unsigned int __broadcast_seq ;
};
union __anonunion_pthread_cond_t_14 {
   struct __anonstruct___data_15 __data ;
   char __size[48] ;
   long long __align ;
};
struct __anonstruct___data_15;
union __anonunion_pthread_mutexattr_t_13;
typedef union __anonunion_pthread_mutexattr_t_13 pthread_mutexattr_t;
union __anonunion_pthread_mutexattr_t_13 {
   char __size[4] ;
   long __align ;
};
union __anonunion_pthread_mutex_t_11;
typedef union __anonunion_pthread_mutex_t_11 pthread_mutex_t;
struct __pthread_internal_slist {
   struct __pthread_internal_slist *__next ;
};
typedef struct __pthread_internal_slist __pthread_slist_t;
union __anonunion____missing_field_name_12 {
   int __spins ;
   __pthread_slist_t __list ;
};
struct __pthread_mutex_s {
   int __lock ;
   unsigned int __count ;
   int __owner ;
   int __kind ;
   unsigned int __nusers ;
   union __anonunion____missing_field_name_12 __annonCompField1 ;
};
union __anonunion_pthread_mutex_t_11 {
   struct __pthread_mutex_s __data ;
   char __size[24] ;
   long __align ;
};
struct __pthread_mutex_s;
union __anonunion____missing_field_name_12;
struct __pthread_internal_slist;
union __anonunion_pthread_attr_t_10;
typedef union __anonunion_pthread_attr_t_10 pthread_attr_t;
union __anonunion_pthread_attr_t_10 {
   char __size[36] ;
   long __align ;
};
typedef unsigned long pthread_t;
typedef __u_quad_t __fsfilcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
typedef __u_quad_t __fsblkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __blkcnt64_t blkcnt64_t;
typedef unsigned long __fsfilcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
typedef unsigned long __fsblkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __blkcnt_t blkcnt_t;
typedef __blksize_t blksize_t;
typedef long __fd_mask;
typedef __fd_mask fd_mask;
struct __anonstruct_fd_set_9 {
   __fd_mask fds_bits[1024 / (8 * (int )sizeof(__fd_mask ))] ;
};
typedef __sigset_t sigset_t;
typedef int __sig_atomic_t;
typedef int register_t;
typedef unsigned long long u_int64_t;
typedef unsigned int u_int32_t;
typedef unsigned short u_int16_t;
typedef unsigned char u_int8_t;
typedef long long int64_t;
typedef short int16_t;
typedef signed char int8_t;
typedef unsigned short ushort;
typedef __suseconds_t suseconds_t;
typedef __useconds_t useconds_t;
typedef int __key_t;
typedef __key_t key_t;
typedef char *__caddr_t;
typedef __caddr_t caddr_t;
typedef int __daddr_t;
typedef __daddr_t daddr_t;
typedef unsigned int __id_t;
typedef __id_t id_t;
typedef __off64_t off64_t;
typedef __nlink_t nlink_t;
typedef __dev_t dev_t;
typedef __ino64_t ino64_t;
typedef __ino_t ino_t;
typedef __off64_t __loff_t;
typedef __loff_t loff_t;
struct __anonstruct___fsid_t_7;
typedef struct __anonstruct___fsid_t_7 __fsid_t;
typedef __fsid_t fsid_t;
typedef __u_quad_t u_quad_t;
typedef __quad_t quad_t;
typedef unsigned long __u_long;
typedef __u_long u_long;
typedef unsigned int __u_int;
typedef __u_int u_int;
typedef unsigned short __u_short;
typedef __u_short u_short;
typedef unsigned char __u_char;
typedef __u_char u_char;
typedef __quad_t *__qaddr_t;
typedef long __swblk_t;
typedef __u_quad_t __rlim64_t;
typedef unsigned long __rlim_t;
struct __anonstruct___fsid_t_7 {
   int __val[2] ;
};
typedef unsigned long long __uint64_t;
typedef long long __int64_t;
typedef unsigned int __uint32_t;
typedef unsigned short __uint16_t;
typedef short __int16_t;
typedef unsigned char __uint8_t;
typedef signed char __int8_t;
typedef __locale_t locale_t;
struct __locale_data;
struct __locale_struct {
   struct __locale_data *__locales[13] ;
   unsigned short const   *__ctype_b ;
   int const   *__ctype_tolower ;
   int const   *__ctype_toupper ;
   char const   *__names[13] ;
};
struct __anonstruct_lldiv_t_6 {
   long long quot ;
   long long rem ;
};
struct __anonstruct_ldiv_t_5 {
   long quot ;
   long rem ;
};
struct __anonstruct_div_t_4 {
   int quot ;
   int rem ;
};
union __anonunion___WAIT_STATUS_3;
typedef union __anonunion___WAIT_STATUS_3  __attribute__((__transparent_union__)) __WAIT_STATUS;
union wait;
union __anonunion___WAIT_STATUS_3 {
   union wait *__uptr ;
   int *__iptr ;
};
struct __anonstruct___wait_stopped_2 {
   unsigned int __w_stopval : 8 ;
   unsigned int __w_stopsig : 8 ;
   unsigned int  : 16 ;
};
struct __anonstruct___wait_terminated_1 {
   unsigned int __w_termsig : 7 ;
   unsigned int __w_coredump : 1 ;
   unsigned int __w_retcode : 8 ;
   unsigned int  : 16 ;
};
union wait {
   int w_status ;
   struct __anonstruct___wait_terminated_1 __wait_terminated ;
   struct __anonstruct___wait_stopped_2 __wait_stopped ;
};
struct __anonstruct___wait_stopped_2;
struct __anonstruct___wait_terminated_1;
struct _IO_FILE *_coverage_fout  ;
